theiterators/kebs
57.5
Adequate · 7 November 2026
4.5k
lines of production code
Scala
primary language
4
measurements over time
What this system is
Kebs is a Scala library that eliminates boilerplate by providing automatic type-class derivation for value classes, enums, and tagged types. It offers extensive integrations with popular HTTP frameworks (Akka HTTP, Pekko HTTP, http4s), JSON libraries (Circe, Play JSON, Spray JSON), and database mappers (Slick, Doobie). The system supports both Scala 2 and Scala 3, enabling seamless serialization, deserialization, and routing without manual conversion logic.
How it got here
2017–2021 — Kebs 2.0 migration and Scala 3 support
21 changes.
The project underwent a major restructuring to support Scala 3 and transition from Akka to Apache Pekko, introducing Kebs 2.0 with a new package layout and generic type-class derivation. Legacy macro-based implementations for Slick, Play JSON, and Spray JSON were removed in favor of simplified, instance-based converters and new integrations like Circe and JSON Schema. The core library was refocused on general-purpose boilerplate elimination, adding comprehensive support for time and utility types while updating documentation and build infrastructure.
2022–2024 — Framework integration and Scala 3 migration
30 changes.
This period focused on expanding Kebs' ecosystem support by adding integration modules for major HTTP frameworks (Akka, Pekko, http4s), database libraries (Slick, Doobie), and serialization formats (Circe, Play, Spray, PureConfig). Concurrently, the codebase underwent a significant migration to support Scala 3, introducing native implementations for opaque types, enums, and automatic derivation across all new and existing modules.
2025 — Library integrations and documentation site launch
5 changes.
This period focused on expanding the library's ecosystem by adding ScalaCheck and Baklava integrations for automated testing and HTTP handling. Simultaneously, the project launched a new Docusaurus-based documentation website, featuring a redesigned homepage and updated static assets to improve user onboarding and visibility.
Features
Add Baklava integration for query params, path params, headers, and schemas
The baklava module now provides implicit conversions to support the Baklava HTTP library for query parameters, path parameters, and headers, as well as JSON Schema generation. This includes support for value classes and instance converters (e.g., LocalDate, UUID) for standard types, and specific handling for enumerations (including uppercase/lowercase variants) and value enums. The implementation ensures that enum names and values are correctly serialized in params and reflected in schema definitions.
baklava · high confidence
Add Pekko HTTP matchers and unmarshallers for Kebs types
This change introduces new support for Pekko HTTP in the Kebs library by adding path matchers and unmarshallers. Users can now seamlessly extract Pekko HTTP path segments and query parameters into Kebs-managed types, including value classes, tagged types, and enumerations (both standard and value-based). The implementation provides implicit conversions for segment matching (e.g., \Segment.as\[T\]\, \Segment.to\[T\]\) and unmarshalling from strings, integers, and form fields, enabling type-safe route definitions that automatically handle conversion and validation for Kebs-defined types.
pekko-http · high confidence
Add http4s integration for path and query parameter decoding
The Kebs library now provides an http4s module that enables automatic decoding of path variables and query parameters for value classes, instance converters, and enums. This allows users to seamlessly integrate Kebs types into http4s routes without manual parsing logic.
http4s/shared · high confidence
Add spray-json integration for Scala 2 and Scala 3
Users can now serialize and deserialize case classes to/from JSON using the spray-json library on both Scala 2 and Scala 3. The Scala 2 implementation provides implicit \RootJsonFormat\ generation via macros, including support for snakified and capitalized field naming conventions, as well as recursive format handling. The Scala 3 implementation leverages inline macros and \Mirror\ types to automatically derive JSON formats, supporting configurable field naming strategies and null option handling.
spray-json/src/main/scala-2 · high confidence
Added Circe codecs for tagged types
The library now provides automatic JSON serialization and deserialization support for tagged types via Circe. By importing the new \pl.iterators.kebs.tagged.circe\ package, users can seamlessly encode and decode values wrapped in the \@@\ tagging syntax for String, UUID, BigDecimal, Int, and Json types without needing to write custom codecs manually.
tagged/shared · high confidence
Added Circe serialization support for Kebs enums
New files in the circe module now provide implicit Encoder and Decoder instances for Kebs enums. Users can serialize and deserialize enums as strings using their names, with optional support for lowercase or uppercase formatting via specific traits.
circe/src/main/scala · high confidence
Added Doobie integration for value classes and enums
Users can now automatically map Kebs value classes and enums to and from database columns via Doobie. This change introduces new implicit Meta instances in the doobie module that handle value class wrappers (including arrays and option-wrapped arrays) and standard string-based enums (with support for uppercase and lowercase naming conventions), as well as value-based enums. The package structure has been reorganized, moving the main Doobie trait from the play-json module to the new doobie module.
doobie/src/main · high confidence
Added HStore and TaggedMeta usage examples
The examples module now includes demonstration code for using Kebs with PostgreSQL HStore integration (HStoreExtensionMethods.scala) and tagged types (TaggedMeta.scala). The HStore example illustrates how to map complex types like YearMonth within HStore columns using KebsSlickSupport, while the TaggedMeta example shows how to define and use tagged types with validation logic.
examples · high confidence
Added Kebs integration for Enumatum and Enumatum-values
New source files in the enumeratum module provide \EnumLike\ and \ValueEnumLike\ instances for Enumatum enums, enabling seamless interoperability between Kebs and Enumatum. The implementation includes Scala 2 macros in \KebsEnumeratum\ and \KebsValueEnumeratum\ to derive these instances at compile time, as well as Scala 3 inline implementations using \Mirror\ and \summonInline\ to achieve the same functionality without macros.
enumeratum/src/main · high confidence
Added Kebs integration for http4s path matchers and unmarshallers
New source files in the http4s-stir/shared module introduce support for Kebs types within http4s routing and request handling. The \KebsHttp4sStirMatchers\ trait provides implicit conversions to map path segments to Kebs value classes, enums, and instance converters, while \KebsHttp4sStirUnmarshallers\ supplies unmarshallers for Kebs enums (including value enums with underlying String, Int, Long, Short, and Byte types) and value classes, enabling seamless deserialization of these types in http4s endpoints.
http4s-stir/shared · high confidence
Added Play JSON serialization support for enums and value classes
The play-json module now includes new traits and package objects that provide automatic JSON serialization and deserialization for Kebs enums and value classes. Users can now seamlessly convert enum instances to and from JSON strings (with optional case-insensitive, lowercase, or uppercase matching) and serialize value classes using their underlying representations, eliminating the need for manual JSON formatting logic.
play-json/src/main/scala/pl/iterators/kebs/playjson · high confidence
Added PureConfig integration for Kebs value classes
Users can now seamlessly integrate Kebs-generated value classes with PureConfig. This change introduces implicit ConfigReader and ConfigWriter instances that automatically handle the conversion between PureConfig's underlying primitive types and Kebs value classes, allowing for straightforward configuration loading and saving without manual mapping logic.
pureconfig · high confidence
Added Scala 3 Scalacheck Arbitrary derivation support
The scalacheck module now includes a new \ScalacheckInstancesSupport\ trait for Scala 3 that automatically derives \Arbitrary\ instances for types using Scala 3's inline derivation capabilities via the \io.github.martinhh.derived.scalacheck\ library.
scalacheck/src/main/scala-3 · high confidence
Added Scala 3 implementation for Kebs Circe integration
A new Scala 3-specific implementation of the Kebs Circe module has been added, providing automatic derivation of JSON encoders and decoders for value classes and instance converters. This includes support for snake\_case and PascalCase naming conventions via dedicated traits, enabling seamless JSON serialization for Kebs-defined types in Scala 3 projects.
circe/src/main/scala-3 · high confidence
Added Slick support for tagged types
Users can now use tagged types (e.g., \Long @@ IdTag\) directly with Slick column mappings. This change introduces the \KebsTaggedSlickSupport\ trait and corresponding implicits, allowing tagged types to be automatically mapped to their base column types in Slick database operations, as verified by the new \SlickTaggedColumnTypeTests\.
tagged/jvm · high confidence
Added URI to String conversion instance
A new \URIString\ trait has been added to the \instances/net\ package, providing an implicit \InstanceConverter\ that converts \java.net.URI\ objects to their string representation. This allows users to easily serialize URI instances to strings within the Kebs library.
instances/src/main/scala/pl/iterators/kebs/instances/net · high confidence
Added enum serialization support for spray-json
The spray-json module now includes dedicated support for serializing and deserializing Kebs enums. Users can automatically convert enums to their string names (with optional case normalization via uppercase or lowercase traits) and value-based enums to their underlying primitive values, resolving previous issues where enum serialization relied on toString or was missing entirely.
spray-json/src/main/scala/pl/iterators/kebs/sprayjson · high confidence
Initial release of opaque type support
The \opaque\ module is introduced, providing a trait to create Scala 3 opaque types with optional validation and transformation. Users can now define opaque types that enforce constraints via a \validate\ method (returning \Either\ for safe creation or throwing on failure) and support unwrapping, unsafe creation, and automatic derivation of \ValueClassLike\ and other typeclasses.
opaque · high confidence
Initial website setup with Docusaurus and Scala syntax highlighting
The website is now built using Docusaurus, featuring a new configuration that enables syntax highlighting for both Java and Scala code blocks. The site is configured for GitHub Pages deployment under the /kebs/ base URL, includes a documentation sidebar, and prepares for future Docusaurus v4 compatibility.
website · high confidence
Introduce Kebs JSON Schema integration
The jsonschema module now provides automatic JSON Schema generation for Kebs value classes and case classes. Users can mix in the KebsJsonSchema trait to get implicit JsonSchemaWrapper instances for generic types via a macro, and can additionally mix in KebsJsonSchemaPredefs to get built-in support for ZonedDateTime, YearMonth, URL, and URI types.
jsonschema · high confidence
New Akka HTTP matchers and unmarshallers for Kebs types
This change introduces new implicit matchers and unmarshallers in the \akka-http\ module, enabling seamless integration of Kebs value classes, enums, and instance converters with Akka HTTP routing. The \KebsAkkaHttpMatchers\ trait provides path matchers that automatically convert path segments to Kebs value classes, value enums, and standard enums (case-insensitive). The \KebsAkkaHttpUnmarshallers\ trait adds unmarshallers for these same types, allowing Akka HTTP to automatically deserialize request bodies and query parameters into Kebs types. This simplifies route definitions by removing the need for manual conversion logic.
akka-http/src/main · high confidence
New ScalaCheck integration for automatic arbitrary generation
The scalacheck module now provides a KebsArbitrarySupport trait that supplies implicit Arbitrary instances for common types, including value classes, Java time types (Instant, LocalTime, LocalDate, LocalDateTime, ZonedDateTime), Duration, URI, URL, and Seq. A new package-level generate function allows users to produce random instances of any type with an Arbitrary instance using a specified or random seed, facilitating easier property-based testing.
scalacheck/src/main/scala · high confidence
New Slick support for HStore columns and value classes
This change introduces the \KebsSlickSupport\ trait and \KebsHStoreColumnExtensionMethods\ class, enabling seamless integration of Kebs value classes and instance converters with Slick database columns. Users can now map value classes and custom instance converters to standard Slick columns, including support for HStore maps with automatic type conversion for common types like Int, Long, String, and Boolean. Additionally, the library provides extension methods for HStore operations such as key existence checks, containment, and concatenation, allowing more expressive database queries.
slick/src/main · high confidence
New time and utility instance formatters
The library now provides a comprehensive set of new implicit formatters for Java time types (such as LocalDate, LocalDateTime, ZonedDateTime, Duration, Period, and Year) and utility types (UUID, Locale, Currency). These instances, located in the \instances\ module, enable seamless conversion between these types and their standard string representations (mostly ISO-8601) or numeric values (Int/Long), using the new \InstanceConverter\ mechanism.
instances/src/main/scala/pl/iterators/kebs/instances/time · high confidence
Scala 2 Arbitrary instance derivation via Magnolify
The Scala 2 module now provides a \ScalacheckInstancesSupport\ trait that automatically derives \Arbitrary\ instances for types using Magnolify's macro-based generation. This allows users to seamlessly integrate Kebs-generated case classes with ScalaCheck property testing without manually defining arbitrary instances.
scalacheck/src/main/scala-2 · high confidence
Support for Scala 3 enums and value enums
The enum module now provides derivation support for Scala 3's native enum types via the new KebsEnum and KebsValueEnum traits. This allows users to automatically generate EnumLike and ValueEnumLike instances for standard Scala 3 enums and value-based enums, complementing the existing Scala 2 Enumeration support.
enum · high confidence
Removals
Removal of Slick macro-based type mappers
The \KebsEnumMacros\ and \KebsMacros\ files have been deleted, removing the macro-based implementation for generating Slick \Isomorphism\ type mappers. This eliminates the automatic generation of column mappings for single-element case classes and enumerations (including variants for name casing and index), meaning users can no longer rely on these specific macro expansions for Slick database column definitions.
macros · high confidence
Removal of legacy KebsSpray and KebsEnumFormats traits
The \KebsSpray\ and \KebsEnumFormats\ traits, which previously provided implicit JSON formats for case classes and enumeratum enums via macros, have been removed from the \pl.iterators.kebs.json\ package. Users relying on these specific traits for automatic serialization and deserialization of products and enums in spray-json will need to adopt the updated API, which likely involves using the new \InstanceConverter\-based mappers or other provided formats introduced in this release.
spray-json/src/main/scala/pl/iterators/kebs/json · high confidence
Removal of legacy macro implementations for spray-json
The legacy macro implementations for spray-json serialization (\KebsSprayMacros\ and \KebsSprayEnumMacros\) have been removed. This deletion eliminates the previous macro-based approach for generating JSON formats for case classes and enumeratum enums, indicating a shift in how the library handles spray-json integration (likely towards the simplified or core-module implementations mentioned in the commit history).
spray-json-macros · high confidence
Removed Play JSON macro support for enumeratum and flat case classes
The \play-json-macros\ module no longer provides macro-based JSON serialization for enumeratum enums or single-element (flat) case classes. The \KebsPlayEnumMacros\ and \KebsPlayMacros\ files have been deleted, removing the ability to automatically generate \Reads\ and \Writes\ for these types within this library. Users relying on these specific macro features for Play JSON integration will need to migrate to alternative solutions, such as the \enumeratum-play-json\ library mentioned in the commit history, or implement their own serialization logic.
play-json-macros · high confidence
Removed Spray JSON benchmark implementation
The benchmark file for Spray JSON serialization has been deleted from the benchmarks module. This removes the specific performance comparison data and code related to the Spray JSON library from the benchmark suite.
benchmarks · high confidence
Removed enumeratum JSON format support from play-json module
The \KebsEnumFormats\ trait and the \enums\ package object, which previously provided implicit \Reads\ and \Writes\ for enumeratum \EnumEntry\ types (including uppercase and lowercase variants), have been removed from the \play-json\ module. Users relying on these implicit conversions for serializing enumeratum enums to JSON must now migrate to the \enumeratum-play-json\ library, which is the designated source for this functionality.
play-json/src/main/scala/pl/iterators/kebs/json/enums · high confidence
Behavioural changes
Consolidated instance traits for time, utility, and network types
The library now provides a unified \KebsInstances\ trait that aggregates specific instance groups for time, utility, and network types. Users can import this single trait to access serialization and conversion support for \UUID\, \Currency\, \Locale\, \URI\, and various Java Time classes (such as \LocalDate\, \ZonedDateTime\, \Duration\, and \Period\). This change simplifies setup by replacing the need to mix in multiple individual traits with one comprehensive import.
instances/src/main/scala/pl/iterators/kebs/instances · high confidence
Core library refactored to support Scala 3 and new type-class derivation
The core module has been significantly restructured to support Scala 3 alongside Scala 2, introducing new \ValueClassLike\ macros for deriving type-class instances (such as \Numeric\, \Fractional\, \Integral\, \Equiv\, and \PartialOrdering\) for value classes and boxed types. This change replaces the previous Slick-centric \Kebs\ and \KebsEnums\ traits with a more general-purpose support system, including new \EnumLike\ and \ValueEnumLike\ traits for enum handling and an \InstanceConverter\ for object-value conversions. The old Slick isomorphism macros and associated tests have been removed from this core module, shifting the focus to generic type-class derivation and naming conventions like \SnakifyVariant\.
core · high confidence
Default case class flattening behavior changed to non-flat
The circe integration in the Scala 2 module now defaults to non-flat JSON encoding and decoding for case classes. Previously, single-element case classes (value classes) were automatically flattened into their underlying type; this behavior is now disabled by default, meaning these classes will serialize to a JSON object with a single field instead. Users who require the previous flat format must explicitly opt-in using the provided implicits.
circe/src/main/scala-2 · high confidence
Major documentation overhaul and build configuration updates
The project documentation has been significantly restructured: the legacy CHANGES.md file has been removed, and the README.md has been rewritten to focus on Kebs as a general boilerplate-elimination library supporting Scala 2.13 and 3, with links to the new Docusaurus-based documentation site. Build infrastructure has been updated with new configuration files including .scala-steward.conf to ignore Akka dependency updates, .sbtopts for increased JVM memory and timezone settings, and .mergify.yml to automate merging of Scala Steward PRs. The scalafmt configuration has been updated to version 3.11.3 with Scala 3 dialect support, and .gitignore has been expanded to include build server protocol and macOS-specific files.
(repo-wide) · high confidence
Migration to Apache Pekko and Kebs 2.0 with new JSON and Slick integrations
The library has upgraded its HTTP foundation from Akka HTTP to Apache Pekko HTTP, requiring users to update imports from \akka.http\ to \org.apache.pekko.http\. This release introduces Kebs 2.0, which restructures the package layout (e.g., \pl.iterators.kebs.json\ to \pl.iterators.kebs.playjson\) and provides new integrations including \KebsSprayJson\ for Scala 3, \KebsSlickSupport\ for simplified Slick type mappings, and \KebsCirce\ for automatic Circe encoder/decoder derivation. The \@tagged\ macro annotation has also been updated to support Scala 3, enabling type-safe tagged types with automatic companion object generation for validation and conversion.
repository · high confidence
Redesigned documentation homepage with feature highlights and quick start
The documentation site now features a redesigned homepage that includes a hero section with a 'Get Started' link, a 'before/after' code comparison illustrating how Kebs eliminates boilerplate, a feature cards section highlighting zero-boilerplate derivation, strong type support, and Scala 2 & 3 compatibility, and a quick start installation guide. The site's visual theme has also been updated to match the Kebs logo colors (dark red, orange-red, amber) in both light and dark modes.
website/src · high confidence
Removal of EnumMacroUtils for simplified enumeratum support
The \EnumMacroUtils\ class, which provided macro-based utilities for mapping enumeratum enum entries to strings and integers (including case-insensitive and case-specific mappings), has been removed. This change simplifies the library's support for enumeratum by reducing reliance on complex macros in favor of more direct code implementations.
macro-utils · high confidence
Removal of legacy KebsPlay trait with flat-reads/writes macros
The \KebsPlay\ trait, which provided implicit \Reads\ and \Writes\ macros for automatic JSON serialization of case classes, has been removed from the \play-json\ module. This change eliminates the previous default behavior of flattening nested structures during JSON conversion, aligning with the project's shift to make non-flat variants the default. Users relying on this trait for automatic JSON generation will need to update their imports or use the new instance-based converters provided in the updated module structure.
play-json/src/main/scala/pl/iterators/kebs/json · high confidence
Updated static assets for Docusaurus v3 migration
The website's static assets have been updated to support the migration to Docusaurus v3. This includes adding a .nojekyll file to prevent GitHub Pages from processing the site with Jekyll, and replacing the previous logo and illustration SVGs (undraw\_docusaurus\_mountain.svg, undraw\_docusaurus\_react.svg) with new versions compatible with the new documentation site structure.
website/static · high confidence
Test coverage
Added comprehensive test coverage for Slick integration features; Added cross-platform tests for Kebs integration with http4s and http4s-stir; Added test coverage for Akka HTTP unmarshalling and route matching; Added test coverage for Play JSON serialization of enums and standard types; Added test coverage for spray-json integration; Added tests for Doobie typeclass instances; Added tests for EnumLike and ValueEnumLike derivation; Added tests for Kebs Circe JSON serialization formats and instances; Added tests for ScalaCheck generator support; Added tests for URI instance conversion; Added tests for tagged-meta JVM integration with Circe, Spray JSON, and JsonSchema; Added tests for time and utility instance converters; Removed enumeratum integration tests; Removed legacy spray-json test suites.
Dependencies
Upgrade Docusaurus to v3 and React to v19 for the documentation site
The website build has been updated to use Docusaurus 3.10.2 (including the @docusaurus/faster plugin) and React 19.0.0, with the Node.js engine requirement raised to \>=20.0. This upgrade ensures compatibility with modern tooling and performance improvements in the documentation generation pipeline.
(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 59 → 57 (-1.7)
- Rubric changed (rubric-2026.10.5 → rubric-2026.11.2) — scores are not directly comparable.
Lenses
- Code Health 75 → 75 (+0.0)
- Architecture 99 → 99 (+0.0)
- Maturity 59 → 59 (-0.3)
- Readiness 46 → 46 (+0.0)
- Security 79 → 65 (-13.9)
- Performance 100 → 100 (+0.0)
Resolved (3)
- Dependency hygiene PARTLY measured — sbt declarations read, no exact version to grade for currency
- Documentation: no project overview (docs/pureconfig.md)
- Off-boarding risk: anonymized user #1
New (1)
- Dependency hygiene PARTLY measured — sbt declarations read, dependency currency not (Maven Central unreachable)
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
theiterators/kebs 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 7 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 7d9a28815c63a2a9be474401387cdc0b4e9dbde9 — the exact code this score is about.
- Scored under rubric-2026.11.2 — 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.3+preprod-5f8314471808.