softwaremill/tapir

Tapir is a functional, type-safe API description library for Scala that allows developers to define HTTP endpoints, gRPC services, and WebSocket connections using a unified domain-specific language. It provides interpreters to generate executable client and server code for a wide variety of backends, including http4s, Netty, Pekko, and ZIO HTTP, while supporting multiple effect systems like Cats Effect and ZIO. The system features automatic schema derivation for case classes and enums, extensive integration with JSON libraries, and built-in support for OpenAPI documentation generation and code generation from specifications.

63 changes.

This period focused on a major refactoring of the Tapir core API, introducing a new Codec abstraction, restructuring endpoint models, and enhancing generic schema derivation. It also involved extensive expansion of server and client interpreters to support modern backends like http4s Ember, ZIO, and Pekko, alongside the addition of numerous JSON library integrations and comprehensive cross-platform test coverage.

90 changes.

This period focused on modernizing the core library with comprehensive Scala 3 macro-based schema derivation and stabilizing Scala 2 derivation via Magnolia. It also significantly expanded the ecosystem by introducing new server interpreters for Armeria, Pekko HTTP, and ZIO HTTP, alongside new infrastructure-as-code modules for AWS CDK, SAM, and Terraform.

52 changes.

This period focused on significantly expanding Tapir's runtime support by adding interpreters for Pekko, Helidon Nima, Play 2.9, and direct-style AWS Lambda, alongside new WebSocket capabilities for Scala.js. It also introduced comprehensive observability features through OpenTelemetry tracing and metrics integrations, while enhancing the OpenAPI code generator with robust support for complex oneOf schemas and improved test coverage.

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

Introduces a new \DatadogMetrics\ implementation that enables collecting request metrics via the StatsD protocol. Users can now track active requests, total request counts, and request durations (split by headers and body phases) with configurable namespaces and labels, and easily integrate these metrics into their server configuration via a provided interceptor.

metrics/datadog-metrics/src/main · high confidence

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

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

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

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

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

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

Introduces a new \OpenTelemetryMetrics\ component that enables collecting HTTP server metrics compliant with OpenTelemetry semantic conventions. Users can now register standard metrics such as \http.server.active\_requests\ (up-down-counter), \http.server.request.total\ (counter), and \http.server.request.duration\ (histogram in seconds) by providing an OpenTelemetry \Meter\. The implementation includes default labels for request method, URL scheme, route, response status code, and error type, and provides a \metricsInterceptor\ to easily integrate these metrics into the server's request handling pipeline.

metrics/opentelemetry-metrics/src/main · high confidence

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

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

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

Introduces a new server interpreter for Apache Pekko HTTP, enabling users to run Tapir endpoints on this runtime. This includes full support for Pekko Streams, WebSockets, and Server-Sent Events (SSE), along with configuration options for interceptors, file handling, and logging. The implementation also handles request body parsing, response body serialization, and specific error scenarios like stream size limits.

server/akka-grpc-server, server/pekko-http-server · high confidence

A new example demonstrating Pekko gRPC integration has been added to the grpc/pekko-examples module. This includes a Protobuf definition for a Library service with an AddBook RPC, along with Scala code providing a server implementation using Pekko gRPC and a client example to interact with it.

grpc/pekko-examples · high confidence

This change introduces a new server interpreter for Pekko gRPC, enabling users to run Tapir endpoints on a Pekko-based gRPC server. The implementation includes request body handling (PekkoGrpcRequestBody) to decode incoming gRPC frames into raw types, and response body handling (PekkoGrpcToResponseBody) to encode Tapir responses into gRPC frames with appropriate content types. It also provides the PekkoGrpcServerInterpreter trait to wire these components together, allowing existing Tapir endpoint definitions to be served via the Pekko gRPC protocol.

metrics/prometheus-simpleclient-metrics, server/pekko-grpc-server · high confidence

A new client module for Play 2.9 has been added, providing the \PlayClientInterpreter\ to convert Tapir endpoints into Play \StandaloneWSRequest\ objects. This implementation supports encoding path, query, header, and body parameters, handling both standard and streaming bodies, and parsing responses for success and error outputs. The module includes configuration via \PlayClientOptions\ and is accompanied by basic and streaming test suites to verify client behavior.

client/play29-client · high confidence

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

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

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

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

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

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

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

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

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

Introduces a new server interpreter module for the Armeria backend that integrates with ZIO 2. This adds \ArmeriaZioServerInterpreter\ and \ArmeriaZioServerOptions\ to allow users to run Tapir endpoints using ZIO effects (\RIO\) and ZIO streams, including support for streaming request/response bodies and configurable interceptors. The change also includes the necessary ZIO-specific monad instances and test suites to validate the integration.

server/armeria-server/zio · high confidence

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

Introduces a new ZIO-based metrics implementation that exposes request active count (gauge), total request count (counter), and request duration (histogram) via ZIO Metrics. This allows users to monitor server performance using ZIO's native metric system with configurable namespaces and labels.

metrics/zio-metrics/src/main · high confidence

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

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

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

This change introduces new direct-style server interpreters and runtime handlers for AWS Lambda, allowing users to run Tapir endpoints using Cats Effect (IO/Resource) or ZIO (RIO) without needing the previous indirect or ZIO-HTTP-based approaches. The \serverless/aws/lambda-cats-effect\ module now provides \AwsCatsEffectServerInterpreter\ and \AwsLambdaRuntime\ to handle invocations via the AWS Lambda Runtime API, while \serverless/aws/lambda-zio\ adds \AwsZioServerInterpreter\ and \ZioLambdaHandler\ for ZIO-based applications. These components include specific server options for configuring interceptors and response encoding, and a Scala.js handler for browser-based testing or simulation.

serverless/aws/lambda-cats-effect · high confidence

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

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

A new example file, GrpcSimpleBooksExample.scala, has been added to demonstrate a basic gRPC server and client setup. This example defines a simple 'AddBook' endpoint that accepts book details and returns a generated book ID, illustrating how to use Tapir's gRPC integration with Akka HTTP. It includes both server-side logic for handling requests and a client-side component for testing the interaction, along with a proto schema generator to create the necessary protocol buffer code.

grpc/examples/src/main/scala · high confidence

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

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

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

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

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

This change introduces a new integration module for the uPickle JSON library, providing codecs and body/query input definitions that allow users to serialize and deserialize data using uPickle's ReadWriter typeclass within Tapir endpoints. The implementation includes \jsonBody\ and \jsonBodyWithRaw\ for handling request/response bodies, \jsonQuery\ for parsing JSON query parameters, and a \readWriterCodec\ that maps uPickle read/write operations to Tapir's decoding/encoding framework, wrapping failures in \JsonDecodeException\.

json/tethys, json/upickle/src/main · high confidence

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

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

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

A new Protobuf definition file (simple\_books\_example.proto) has been added to the examples directory, defining a Library service with an AddBook RPC. This service allows clients to add books by providing a title and description, returning a SimpleBook object with an ID, title, and description. The generated Java code will be placed in the sttp.tapir.grpc.examples.grpc\_simple\_books\_example.gen package with multiple files enabled.

grpc/examples/src/main/protobuf · high confidence

This change introduces a new \grpc/protobuf\ module that allows users to generate Protocol Buffer (\.proto\) definition files directly from Tapir gRPC endpoints. The implementation includes an interpreter (\ProtobufInterpreter\) that maps Tapir endpoint inputs and outputs to protobuf messages and services, supporting scalar types (int, long, string, etc.), repeated fields, nested products, and coproducts (oneof). A renderer (\ProtoRenderer\) then converts this internal model into valid proto3 syntax, including support for configurable Java package names. The feature is exposed via \ProtoSchemaGenerator\, which can write the generated proto content to a file, and is accompanied by tests verifying the correct translation of Tapir schemas to protobuf structures.

grpc/protobuf · high confidence

This release introduces the \serverless/aws/sam\ module, enabling users to convert Tapir API definitions into AWS Serverless Application Model (SAM) YAML templates. The new \AwsSamInterpreter\ allows configuring Lambda functions (via code or container images), setting timeouts and memory, and defining HTTP API properties including CORS and Lambda authorizers. It also supports injecting runtime parameters into the generated template, providing a programmatic way to scaffold serverless deployments directly from Scala endpoint definitions.

serverless/aws/sam · high confidence

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

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

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

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

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

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

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

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

A new \netty-cats\ module has been added, providing a separate Netty server implementation built on top of Cats Effect. This interpreter allows Tapir endpoints to be served using \cats.effect.IO\ and integrates fs2 streams for request and response bodies, including support for WebSocket communication. The module includes its own server configuration options, request body handling, and streaming compatibility layer, enabling users to run Tapir servers with Cats Effect's async runtime.

server/netty-server/cats · high confidence

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

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.

client/http4s-client/src/main, server/netty-server/zio · high confidence

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

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

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

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

Added a new \tapir-cats-effect\ module that provides server interpreters for Armeria backed by Cats Effect. This allows users to run Tapir endpoints using \cats.effect.IO\ and other \Async\ types on the Armeria platform, including support for streaming via Fs2 and configurable server options such as interceptors and logging.

server/armeria-server/cats · high confidence

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

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

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

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

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

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

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

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

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

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

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

The ZIO integration for Tapir server endpoints has been introduced, providing a new \ztapir\ package. This includes a \ZTapir\ trait that adds extension methods to Tapir endpoints for defining server logic using ZIO effects (\RIO\), supporting both standard and security-prefixed logic via \ZPartialServerEndpoint\. The integration also includes a \RIOMonadError\ implementation for ZIO's effect type and utilities for serializing and parsing Server-Sent Events (SSE) using ZIO streams.

integrations/zio/src/main · high confidence

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

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

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

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

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

The \sttp.tapir.model\ package now includes several new data structures to support advanced API modeling. A \Delimited\ case class allows representing lists of values separated by a specific delimiter, complementing the existing delimited codec support. \StatusCodeRange\ introduces sealed types for HTTP status code categories (Informational, Success, Redirect, ClientError, ServerError), enabling documentation of status code ranges in dynamic outputs. Additionally, WebSocket handling is enhanced with \UnsupportedWebSocketFrameException\ and \WebSocketFrameDecodeFailure\ to provide specific error reporting for frame issues, while \UsernamePassword\ offers a dedicated model for credential pairs.

core/src/main/scala/sttp/tapir/model · high confidence

Added eight new Scala example applications in the observability directory demonstrating how to integrate Tapir with various tracing and metrics backends. These include OpenTelemetry tracing for Netty sync servers, Otel4s-based metrics and tracing for Cats-effect Netty servers, ZIO OpenTelemetry tracing and Prometheus metrics for ZIO HTTP servers, and standard OpenTelemetry, Prometheus, and DataDog metrics examples for Netty Future-based servers.

examples/src/main/scala/sttp/tapir/examples/observability · high confidence

The server module introduces \PartialServerEndpoint\, \PartialServerEndpointSync\, \PartialServerEndpointWithSecurityOutput\, and \PartialServerEndpointWithSecurityOutputSync\ to represent endpoints where security logic is defined but main logic is not yet provided. These types allow developers to build secured base endpoints and specialize them with specific inputs, outputs, and handlers. Additionally, \ServerEndpoint\ is introduced as the final, fully-defined endpoint type that combines both security and main logic, supporting features like prepending additional security inputs or logic. This change enables more modular and composable server endpoint definitions, particularly for scenarios involving authentication and authorization.

core/src/main/scala/sttp/tapir/server · high confidence

Added a suite of new security examples in the \examples/src/main/scala/sttp/tapir/examples/security\ directory. These include OAuth2 implementations for GitHub (using http4s/Ember) and Google (using Netty sync), a ZIO HTTP example demonstrating reusable base endpoints with bearer token authentication, and Pekko HTTP examples for basic authentication, CSRF token protection, and CORS interception. Additionally, examples for Vert.x CORS handling and external security role verification via interceptors are provided, illustrating how to secure endpoints with cookies, JWTs, and custom server logic.

examples/src/main/scala/sttp/tapir/examples/security · high confidence

This release introduces a new static content API in the \files\ module, providing endpoints to serve files from the local filesystem (\staticFilesGetServerEndpoint\) and resources from the classpath (\staticResourcesGetEndpoint\). The implementation supports HTTP range requests for partial content delivery, ETag-based caching, and automatic serving of pre-gzipped file siblings when the client accepts gzip encoding. It also includes security measures to prevent directory traversal attacks and allows attaching custom headers to the responses.

files · high confidence

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

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

This change introduces the \client/sttp-client4\ module, providing the \SttpClientInterpreter\ (and its streaming and WebSocket variants) that allows you to interpret Tapir endpoints into executable client calls using the sttp client 4 library. This includes support for standard HTTP requests, streaming bodies, and WebSocket connections, enabling you to generate typed client functions from your API definitions.

client/sttp-client4 · high confidence

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

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

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

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

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

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

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

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

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

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

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

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

The generic schema derivation logic has been refactored to use a new \Configuration\ class that allows users to customize how case class fields and subtypes are encoded. Users can now control naming conventions for field names (snake case, screaming snake case, or kebab case) and configure discriminator fields for union types (coproducts), including options to format discriminator values using various naming styles or full type names. This provides finer control over the generated schema structure, particularly for polymorphic types.

core/src/main/scala/sttp/tapir/generic · high confidence

The static file serving components in \sttp.tapir.static\ (including \Files\, \Resources\, and \TapirStaticContentEndpoints\) are now deprecated as of version 1.3.0. Users should migrate to the new \sttp.tapir.files\ API, which provides the updated implementations for serving static files and resources. The deprecated classes remain available for backward compatibility but will be removed in a future release.

core/src/main/scalajvm/sttp/tapir/static · high confidence

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

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

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

The Finatra server module has been migrated to use explicit server interpreters and a new interceptor-based architecture. This introduces a new \FinatraServerOptions\ configuration class that allows customizing interceptors, file creation/deletion, and logging. The request body handling is now implemented via \FinatraRequestBody\ and \FinatraBodyListener\, supporting various raw body types (String, ByteArray, ByteBuffer, InputStream, File, Multipart) and integrating with Finatra's \Buf\ and \Reader\ types. Response body conversion is handled by \FinatraToResponseBody\, mapping Tapir's content types to Finatra's response structures. The interpreter now uses \FinatraRoute\ to map Tapir endpoints to Finatra HTTP routes, with path segment decoding and trailing slash handling. A \TapirController\ trait simplifies route registration in Finatra controllers. Tests have been updated to use the new interpreter structure, with static content and reject tests disabled for Finatra due to platform limitations.

server/finatra-server · high confidence

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

The JSON pickler implementation has been reorganized into a dedicated \sttp.tapir.json.pickler\ package, introducing a new \CreateDerivedEnumerationPickler\ to handle enum derivation and customization more robustly. This change improves error messages for missing picklers, fixes issues with enum case ordering and custom encoding, and allows deriving picklers for non-mirrored types. The \PicklerConfiguration\ now supports \transientNone\ to control \Option\ serialization, and schema derivation has been enhanced to better handle annotations and discriminator values.

json/pickler/src/main · high confidence

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

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

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

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

The core codegen module has been refactored to support Scala 3, introducing version-specific helper files for reserved keyword handling and enabling Scala 3 enum generation. This rewrite includes significant security hardening by validating server URLs and neutralizing untrusted descriptions to prevent code injection ([GHSA redacted]). The generator now supports merging multiple OpenAPI documents, deduplicating schemas across packages, and generating code for a wider range of schema types including oneOf, allOf, maps, and validation constraints.

openapi-codegen/core/src/main · high confidence

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

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

The example code in examples/src/main/scala/sttp/tapir/examples has been re-enabled and updated to demonstrate Tapir's capabilities using Scala 3 and modern server interpreters. The examples now cover a wide range of server backends including http4s (using Ember), ZIO HTTP, Netty (Future, Cats-effect, and sync variants), Armeria, JDK HTTP, and Pekko HTTP. They also showcase various functional effects (Future, IO, ZIO), JSON libraries (circe, zio-json, pickler), and features like Swagger UI documentation, multipart form uploads, static file serving, and partial server logic for authentication.

examples/src/main/scala/sttp/tapir/examples · high confidence

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

The internal package has been restructured to improve how endpoint inputs and outputs are processed. A new \ShowPathTemplate\ object now handles the generation of path and query string representations for endpoints, separating this logic from the main package. The \package.scala\ file introduces a \Params\ union type (\ParamsAsAny\ and \ParamsAsVector\) to standardize the representation of endpoint parameters (no params, single param, or tuples), replacing previous tuple-based handling. Additionally, \RichEndpoint\ and \RichEndpointInput\ implicit classes provide new traversal methods (\traverseInputs\, \asVectorOfBasicInputs\) and sorting logic (\basicInputSortIndex\) to consistently order and access endpoint components like path captures, queries, and auth inputs. Output handling is also refined with \asBasicOutputsList\ and \supportedMediaTypes\ methods that correctly account for \OneOfBody\ variants and metadata in empty outputs, ensuring accurate content negotiation and schema generation.

core/src/main/scala/sttp/tapir/internal · high confidence

The server core's interceptor system has been restructured to provide a more explicit and customizable request handling pipeline. A new \CustomiseInterceptors\ class now serves as the primary entry point for configuring the interceptor stack, allowing users to easily prepend, append, or replace built-in interceptors (such as logging, metrics, CORS, and exception handling) and to customize the \DecodeFailureHandler\. This change introduces dedicated context classes (\DecodeFailureContext\, \DecodeSuccessContext\, \SecurityFailureContext\) to provide richer information to interceptors, and refactors the core \Interceptor\, \RequestHandler\, and \EndpointHandler\ traits to support this new modular architecture. Users can now more precisely control how requests are decoded, how failures are reported, and how the server logic is invoked.

server/core · high confidence

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

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

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

The sbt OpenAPI codegen plugin has been restructured to expose a comprehensive set of configuration options via \OpenApiConfiguration\. Users can now control code generation behavior through new settings, including splitting models into separate files (\seperateFilesForModels\), using head tags for object names (\useHeadTagForObjectName\), enabling custom jsoniter serdes, adding disambiguation codes for ambiguous responses, and configuring package dependencies for model reuse. The plugin also now supports incremental builds by regenerating sources only when input YAMLs or configuration change, and handles cases where the default OpenAPI file does not exist.

openapi-codegen/sbt-plugin/src/main · high confidence

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

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

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

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

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

The core library introduces a new Codec abstraction to handle bi-directional encoding and decoding, alongside a CodecFormat hierarchy to define media types (e.g., JSON, XML, Multipart). The Endpoint model is restructured to explicitly separate security inputs from regular inputs, and the EndpointIO hierarchy is refined with new transput traits (Atom, Basic, Pair) to better model request/response components. Additionally, new types like FieldName, FileRange, and InputStreamRange are added to support detailed field naming, file range requests, and streaming file handling.

core/src/main/scala/sttp/tapir · high confidence

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

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 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 test for jsoniter oneOf round-tripping and recursive schemas; 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 micro-benchmarks for JSON decoding performance; 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 data for builtin typename collision scenarios; Added test for jsoniter serialization of inline enums in Scala 3; Added test for oneOf JSON roundtripping with jsoniter-scala; 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 sttp client integration with ZIO, Pekko, and fs2; Added testing examples for Tapir stubs and MockServer integration; Added tests for Circe JSON decoding errors and schema handling; 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 Play JSON codec integration; Added tests for Prometheus metrics collection; 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 new EndpointVerifier module; 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; 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.

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 watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 74 → 63 (-11.5)
• Rubric changed (rubric-2026.09.8 → rubric-2026.09.16) — scores are not directly comparable.

• Code Health 84 → 63 (-21.1)
• Architecture 99 → 56 (-42.4)
• Maturity 73 → 75 (+1.7)
• Readiness 78 → 74 (-3.8)
• Security 70 → 73 (+3.0)

• Consequences/trade-offs are not present in the visible text (only context and decision are given) (doc/adr/0007-codecs-schemas-configuration.md)
• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)
• Duplicated block (7 lines × 2) (examples/src/main/scala/sttp/tapir/examples/openapi/RedocContextPathHttp4sServer.scala)
• Hotspot: openapi-codegen/core/src/main/scala/sttp/tapir/codegen/dedup/SchemaComparer.scala (openapi-codegen/core/src/main/scala/sttp/tapir/codegen/dedup/SchemaComparer.scala)
• Hotspot: openapi-codegen/core/src/main/scala/sttp/tapir/codegen/endpoints/InAndOutComponents.scala (openapi-codegen/core/src/main/scala/sttp/tapir/codegen/endpoints/InAndOutComponents.scala)
• Hotspot: openapi-codegen/core/src/main/scala/sttp/tapir/codegen/endpoints/SimpleTypes.scala (openapi-codegen/core/src/main/scala/sttp/tapir/codegen/endpoints/SimpleTypes.scala)
• Hotspot: openapi-codegen/core/src/main/scala/sttp/tapir/codegen/json/JsoniterSerdeImpl.scala (openapi-codegen/core/src/main/scala/sttp/tapir/codegen/json/JsoniterSerdeImpl.scala)
• Off-boarding risk: anonymized user #1
• The decision is qualified by trade-offs but the context and consequences/trade-offs sections are both absent (doc/adr/0012-extracting-schema-as-a-module.md)

• Coverage not measured — JavaScript/TypeScript suite
• Duplicated block (6 lines × 2) (examples/src/main/scala/sttp/tapir/examples/openapi/RedocContextPathHttp4sServer.scala)
• End-of-life runtime: .NET netcoreapp3.1
• Hotspot: server/vertx-server/cats/src/main/scala/sttp/tapir/server/vertx/cats/streams/fs2.scala (server/vertx-server/cats/src/main/scala/sttp/tapir/server/vertx/cats/streams/fs2.scala)
• Off-boarding risk: anonymized user #1
• Outdated: io.github.classgraph:classgraph
• SchemaAnnotationsMacro.derived (cognitive 21) (core/src/main/scala-2/sttp/tapir/internal/SchemaAnnotationsMacro.scala)
• SchemaAnnotationsMacro.derived (cyclomatic 17) (core/src/main/scala-2/sttp/tapir/internal/SchemaAnnotationsMacro.scala)
• The decision is qualified by trade-offs but the context and consequences/trade-offs sections are both absent (the body ends before any of them) (doc/adr/0012-extracting-schema-as-a-module.md)

• 30 commits — 29 feature/other, 1 fixes

• project/Versions.scala — 13 commits
• (root) — 3 commits
• .github/workflows — 3 commits
• project/plugins.sbt — 3 commits
• examples/src — 2 commits
• server/netty-server — 2 commits
• core/src — 1 commit
• generated-doc/out — 1 commit
• metrics/opentelemetry-metrics — 1 commit
• openapi-codegen/sbt-plugin — 1 commit

• fix: Fix enumeration does not handle customise annotation (#5481)
• change: Bump VirtusLab/scala-cli-setup from 1.16.0 to 1.17.1 (#5530)
• change: Bump actions/setup-java from 6.0.0 to 6.0.1 (#5522)
• change: Bump sbt/setup-sbt from 1.5.8 to 1.5.9 (#5521)
• change: Harden Netty request-timeout tests against JVM stalls (#5549)
• change: Netty: respond with 408 when the request timeout fires before the body is fully received (#5466)
• change: Release 1.13.32
• change: Remove phase attribute from OpenTelemetry request duration histogram (#5548)
• change: Update aws-lambda-java-runtime-interface-client to 2.12.1 (#5523)
• change: Update http4s-circe, http4s-core, ... to 0.23.37 (#5520)
• change: Update jackson-module-scala to 2.22.3 (#5543)
• change: Update jsoniter-scala-core, ... to 2.41.0 (#5544)
• change: Update model:core to 1.8.1 (#5532)
• change: Update netty-all to 4.2.18.Final (#5518)
• change: Update netty-reactive-streams-http to 3.0.10 (#5538)
• change: Update opentelemetry-api, ... to 1.66.0 (#5527)
• change: Update opentelemetry-exporter-otlp, ... to 1.66.0 (#5528)
• change: Update opentelemetry-semconv to 1.44.0 (#5519)
• change: Update play-ahc-ws-standalone to 2.2.18 (#5534)
• change: Update play-ahc-ws-standalone to 3.0.14 (#5537)
• …and 10 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

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.