theiterators/kebs

Kebs is a Scala library that eliminates boilerplate by providing automatic derivation of type classes for value classes, enums, and tagged types. It offers extensive integration modules for serialization (Circe, Play JSON, Spray JSON), HTTP routing (Akka HTTP, Pekko HTTP, http4s), and database mapping (Slick, Doobie). The system supports both Scala 2 and Scala 3, enabling seamless handling of domain models across various infrastructure layers without manual implementation.

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. Legacy macro-based integrations for Slick, Play JSON, and Spray JSON were removed in favor of dedicated libraries and simplified instance traits, while new modules for JSON Schema and standardized type conversions were added.

29 changes.

This period focused on expanding the library's interoperability by adding first-class support for Scala 3, including opaque types and modern enum definitions. It introduced extensive integration modules for major frameworks such as Slick, Akka HTTP, Pekko HTTP, http4s, and Doobie, alongside serialization libraries like Circe, Play JSON, and Spray JSON. The work also established automated derivation for testing via Scalacheck and configuration via PureConfig, ensuring seamless type-safe handling across the entire Scala ecosystem.

5 changes.

This period focused on expanding the project's ecosystem by adding ScalaCheck generators and Baklava HTTP integration for seamless type mapping. Concurrently, the team established a new Docusaurus-based documentation website, including initial setup, migration to v3, and a redesigned homepage to highlight core features.

This change introduces the \baklava\ module, providing implicit conversions that allow Kebs types (value classes, instance converters, and enums) to be automatically mapped to Baklava's \ToQueryParam\, \ToPathParam\, \ToHeader\, and \Schema\ types. Users can now seamlessly integrate Kebs models with Baklava-powered HTTP routing and schema generation, including support for enum values in uppercase or lowercase formats.

baklava · high confidence

This change introduces new \KebsPekkoHttpMatchers\ and \KebsPekkoHttpUnmarshallers\ traits for the \pekko-http\ module, enabling seamless integration of Kebs value classes, tagged types, and enums within Pekko HTTP routes. Users can now use \.as\ and \.to\ methods on path matchers to convert path segments into value classes (e.g., \Long\ to \Id\) or enums (e.g., \String\ to \Greeting\), and leverage implicit unmarshallers to automatically deserialize query parameters, form fields, and request bodies into these types, including support for value enums and case class composition.

pekko-http · high confidence

Users can now seamlessly integrate Kebs value classes with PureConfig for configuration management. 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 transparent serialization and deserialization of case classes containing value class fields without manual mapping logic.

pureconfig · high confidence

Introduces a new Scala 3 implementation for the Kebs-Circe module, providing automatic JSON encoding and decoding for value classes and instance converters. This addition enables seamless serialization support for Kebs-defined types in Scala 3 projects, including optional snake\_case and PascalCase naming conventions.

circe/src/main/scala-3 · high confidence

Users can now use tagged types (e.g., \Long @@ IdTag\) directly with Slick database columns. This change introduces the \KebsTaggedSlickSupport\ trait, which provides an implicit \ColumnType\ mapping that automatically handles the conversion between tagged values and their underlying base types when using a Slick \JdbcProfile\. A corresponding test confirms that tagged types compile correctly within the Slick API.

tagged/jvm · high confidence

This change introduces a new module providing automatic JSON serialization and deserialization for case classes using the spray-json library. It supports both Scala 2 (via macros) and Scala 3 (via inline macros and Mirrors). The integration includes standard JSON format generation, as well as specialized formats for snake\_case and capitalized camelCase field naming. It also handles value-class-like flattening for single-element case classes, though this behavior is opt-in in Scala 2 to prevent accidental flattening.

spray-json/src/main/scala-2 · high confidence

The examples directory now includes demonstration code for Kebs 2.0 features, specifically showing how HStore extension methods simplify Slick table mappings by replacing manual isomorphism logic with \KebsSlickSupport\, and illustrating the usage of the \@tagged\ macro for creating validated, type-safe tagged types.

examples · high confidence

The library now provides automatic derivation of \EnumLike\ and \ValueEnumLike\ typeclasses for Enumatum enums, supporting both Scala 2 (via macros) and Scala 3 (via inline/deriving). This allows users to seamlessly use Enumatum enumerations with Kebs' core enum utilities, such as converting enum values to name maps or retrieving value sequences, without manual boilerplate.

enumeratum/src/main · high confidence

New source files in the http4s-stir/shared module provide seamless integration with the Kebs library for http4s routing and request handling. The KebsHttp4sStirMatchers trait adds implicit conversions to PathMatcher1, allowing path segments to be automatically converted to Kebs value classes, enums, and value enums. The KebsHttp4sStirUnmarshallers trait provides implicit unmarshallers for Kebs enums, value enums, and value class instances, enabling automatic deserialization of request bodies and query parameters into Kebs types.

http4s-stir/shared · high confidence

The scalacheck module now includes built-in support for generating test data for common Scala and Java types. A new \KebsArbitrarySupport\ trait provides implicit \Arbitrary\ instances for value classes, \Unit\, strings, Java time types (\Instant\, \LocalTime\, \LocalDate\, \LocalDateTime\, \ZonedDateTime\), \Duration\, \URI\, \URL\, and \Seq\. Additionally, a \generate\ utility function has been added to the \pl.iterators.kebs.scalacheck\ package to easily produce instances of any type with an available \Arbitrary\ instance using a specified or random seed.

scalacheck/src/main/scala · high confidence

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 addition enables seamless serialization and deserialization of URI instances within the library's conversion framework.

instances/src/main/scala/pl/iterators/kebs/instances/net · high confidence

The tagged/shared module now includes Circe codecs for serializing and deserializing tagged types. This adds implicit encoders and decoders for String, UUID, BigDecimal, Int, and Json tagged with a type parameter, allowing these values to be seamlessly converted to and from JSON without losing their type-level tags.

tagged/shared · high confidence

Introduces the \KebsHttp4s\ trait and \pl.iterators.kebs.http4s\ package to enable seamless decoding of path variables and query parameters using Kebs type classes. This addition supports automatic conversion for value classes, instance converters, and enums for String, Int, Long, and UUID types, allowing users to leverage Kebs' type-safe representations directly within http4s route definitions.

http4s/shared · high confidence

The doobie module now provides implicit \Meta\ instances for Kebs value classes, enumerations, and instance converters, enabling seamless database mapping. This includes support for standard enums, value enums, and case classes converted to value classes, with specific handling for arrays and optional arrays. Enum mappings can be configured to use uppercase or lowercase string representations via dedicated traits. The integration also supports complex types like \Currency\ and nested structures, ensuring that queries involving these types compile and execute correctly.

doobie · high confidence

The library now includes an \Opaque\ trait for Scala 3 that enables the creation of opaque types wrapping an underlying value. This feature allows users to define custom types that are distinct from their base types at compile time, preventing accidental mixing (e.g., \TestWrappedInt\ cannot be compared directly to \Int\). It supports optional validation and sanitization of the unwrapped value during construction, throwing an exception or returning an error on failure, while also providing an \unsafe\ method to bypass validation. Additionally, the implementation automatically derives a \ValueClassLike\ typeclass, facilitating seamless integration with other library features that rely on value-class-like behavior.

opaque · high confidence

The website has been initialized as a Docusaurus static site, providing a new documentation hub for the Kebs project. This includes configuration for GitHub Pages deployment, a sidebar structure autogenerated from the docs folder, and Prism syntax highlighting extended to support both Java and Scala code blocks.

website · high confidence

The jsonschema module now provides automatic JSON Schema generation for case classes and value classes via the \KebsJsonSchema\ trait and its \materializeSchema\ macro, wrapping the underlying \json.Json.schema\ output in a \JsonSchemaWrapper\. It also includes \KebsJsonSchemaPredefs\ that supply implicit schema definitions for standard types such as \ZonedDateTime\, \YearMonth\, \URL\, and \URI\, allowing users to seamlessly integrate these types into their schema generation without manual configuration.

jsonschema · high confidence

This change introduces new implicit matchers and unmarshallers for the Akka HTTP integration, enabling seamless handling of Kebs-specific types within route definitions. The \KebsAkkaHttpMatchers\ trait adds path matcher conversions for value classes, value enums, and standard enums, allowing routes to automatically map string path segments to these types. Additionally, the \KebsAkkaHttpUnmarshallers\ trait provides unmarshalling support for value classes, instance converters, and various enum types (including primitive-backed value enums), ensuring that request bodies and query parameters are correctly deserialized into Kebs types.

akka-http/src/main · high confidence

The circe module now includes dedicated support for serializing and deserializing Kebs enums via the new \KebsCirceEnums\ and \KebsCirceValueEnums\ traits. Users can import \pl.iterators.kebs.circe.enums.\_\ to get implicit \Encoder\ and \Decoder\ instances for \EnumLike\ and \ValueEnumLike\ types. The implementation provides default case-sensitive encoding/decoding, as well as specific traits (\KebsCirceEnumsUppercase\ and \KebsCirceEnumsLowercase\) to handle case-insensitive or case-normalized enum values. This functionality is exposed through the main \circe\ package object, allowing users to mix in the appropriate casing behavior as needed.

circe/src/main/scala · high confidence

This change introduces the Scala 2 implementation of the Kebs-Circe module, providing automatic JSON encoding and decoding for Kebs value classes and instance converters. The integration includes macro-based derivation for case classes, supporting both standard and snakified/capitalized naming conventions. A key behavioral detail is that flattening single-element case classes into their underlying value is now opt-in; by default, the macros will abort compilation if a flat format is preferred but not explicitly enabled, ensuring explicit control over JSON structure.

circe/src/main/scala-2 · high confidence

This change introduces the \KebsSlickSupport\ trait and associated extension methods, enabling seamless integration of Kebs value classes, instance converters, and enums with Slick database columns. Users can now automatically map value classes and lists of value classes to underlying database types, utilize HStore columns with support for various key-value types (including Int, Long, Boolean, String, and others), and define enum columns with configurable casing (uppercase, lowercase, or default). The implementation provides implicit conversions and column types that handle serialization and deserialization transparently.

slick/src/main · high confidence

The spray-json module now includes dedicated support for serializing and deserializing Kebs enums. Users can automatically convert enum instances to JSON strings using case-insensitive matching by default, or enforce strict lowercase or uppercase matching by importing the respective traits. Value-based enums are also supported, allowing them to be serialized using the JSON format of their underlying value type.

spray-json/src/main/scala/pl/iterators/kebs/sprayjson · high confidence

The library now provides built-in conversion instances for a broad set of Java time and utility types, allowing them to be serialized to and deserialized from standard formats. In the time package, \Year\, \Month\, and \DayOfWeek\ are mapped to integers, while \Duration\, \Instant\, \LocalDate\, \LocalDateTime\, \LocalTime\, \MonthDay\, \OffsetDateTime\, \OffsetTime\, \Period\, \YearMonth\, \ZoneId\, \ZoneOffset\, and \ZonedDateTime\ are mapped to ISO-8601 or standard string representations. Additionally, \Duration\ can be converted to numeric primitives (milliseconds, minutes, nanos, seconds), and \Period\ to integer components (days, months, years). Utility types \UUID\, \Locale\, and \Currency\ are also added, mapping to standard string formats (UUID, IETF BCP 47, and ISO-4217 respectively).

instances/src/main/scala/pl/iterators/kebs/instances/time · high confidence

The play-json module now provides implicit JSON Reads and Writes for value classes and instance converters via the KebsPlayJson trait, and adds comprehensive serialization support for enums (including case-insensitive, lowercase, and uppercase variants) and value enums through the KebsPlayJsonEnums and KebsPlayJsonValueEnums traits.

play-json/src/main/scala/pl/iterators/kebs/playjson · high confidence

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 mix in this trait to enable automatic property-based testing support for their case classes and sealed traits without manual instance definitions.

scalacheck/src/main/scala-2 · high confidence

Users of the Scala 3 version of the library can now automatically derive Arbitrary instances for their types. A new trait, ScalacheckInstancesSupport, provides an inline implicit definition that leverages the io.github.martinhh.derived.scalacheck library to generate these instances using Scala 3's inline and Mirror capabilities, simplifying the setup for property-based testing.

scalacheck/src/main/scala-3 · high confidence

The enum module now supports Scala 3 enums and value enums in addition to the existing Scala 2 Enumeration support. This introduces new \KebsEnum\ and \KebsValueEnum\ traits that use Scala 3's compile-time derivation to automatically generate \EnumLike\ and \ValueEnumLike\ instances, allowing users to seamlessly use the library's enum utilities with modern Scala 3 enum definitions.

enum · high confidence

The \KebsEnumMacros\ and \KebsMacros\ files have been deleted, removing the library's automatic generation of Slick \Isomorphism\ type mappers for case classes and enumerations. Users can no longer rely on these macros to automatically map single-element case classes or enumerations to database columns, requiring manual definition of column mappings or migration to alternative mapping strategies.

macros · high confidence

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

The \KebsSpray\ and \KebsEnumFormats\ traits have been removed from the \pl.iterators.kebs.json\ package. This eliminates the previous macro-based implicit definitions for case class and Enum JSON formats (including uppercase/lowercase variants), meaning users can no longer mix in these specific traits to automatically derive spray-json formats via the old macro interface.

spray-json/src/main/scala/pl/iterators/kebs/json · high confidence

The \KebsSprayMacros\ and \KebsSprayEnumMacros\ source files have been removed from the \spray-json-macros\ module. This change eliminates the direct macro definitions for generating \JsonFormat\ and \RootJsonFormat\ instances for case classes and enumeratum enums, indicating a shift away from the previous macro-based generation strategy in this specific module.

spray-json-macros · high confidence

The benchmark file for Spray JSON serialization (\SprayJsonFormatBenchmark.scala\) has been removed from the benchmarks module. This eliminates the performance comparison data previously generated for the Spray JSON library within this benchmark suite.

benchmarks · high confidence

The play-json-macros module no longer provides JSON serialization support for enumeratum enums or single-element (flat) case classes. The specific macro implementations for these features (KebsPlayEnumMacros and KebsPlayMacros) have been deleted, as this functionality is now handled by the separate enumeratum-play-json library. Users relying on automatic JSON Reads/Writes for enumeratum enums or 1-arity case classes within this module will need to migrate to the dedicated library or provide their own implementations.

play-json-macros · high confidence

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

The core module has been significantly restructured to drop the Slick database mapping features (previously provided by the \Kebs\ and \KebsEnums\ traits) and to add native support for Scala 3. This change introduces a new \ValueClassLike\ macro mechanism that works across both Scala 2 and Scala 3, enabling the automatic derivation of \Numeric\, \Fractional\, \Integral\, \Equiv\, and \PartialOrdering\ type class instances for value-class-like types. Additionally, a new \EnumLike\ trait has been added to provide flexible, map-based enum lookups, and the internal macro utilities have been migrated to use \blackbox\ contexts.

core · high confidence

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

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

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

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

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

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

Added Play JSON format tests for enums and standard library instances; Added comprehensive Slick integration tests for Kebs support; Added comprehensive test coverage for Kebs Circe integration; 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 spray-json integration; Added tests for EnumLike and ValueEnumLike derivation; 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.

The documentation site has been upgraded to Docusaurus 3.10.2, including the @docusaurus/faster plugin, and updated to use React 19. This change also enforces a Node.js engine requirement of version 20.0 or higher for the website build environment.

(dependencies) · high confidence

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

• First survey — no prior run to compare against. CAI 68.

• Code Health 98
• Architecture 98
• Maturity 62
• Readiness 58
• Security 79
• Domain Modelling 100

• 300 commits — 276 feature/other, 24 fixes

• (root) — 124 commits
• (repo) — 34 commits
• project/plugins.sbt — 27 commits
• .github/workflows — 18 commits
• project/build.properties — 15 commits
• scalacheck/src — 12 commits
• circe/src — 11 commits
• baklava/src — 4 commits
• core/src — 4 commits
• doobie/src — 4 commits
• spray-json/src — 4 commits
• website/docusaurus.config.ts — 4 commits
• docs/akka-http.md — 3 commits
• http4s-stir/src — 3 commits
• pekko-http/src — 3 commits
• tagged-meta/src — 3 commits
• enum/src — 2 commits
• examples/src — 2 commits
• http4s/src — 2 commits
• instances/src — 2 commits

• fix: Add git fetch --tags to publish workflow to fix tag detection
• fix: Fix Prism language load order: java before scala
• fix: Fix Website workflow: use Node 22 (Docusaurus 3.10 requires >=20)
• fix: Fix baklava schema support
• fix: Fix broken doc links to other.md, update Scala version in mdoc workflow
• fix: Fix build.sbt
• fix: Fix build.sbt
• fix: Fix release workflow: set SONATYPE_CREDENTIAL_HOST to central.sonatype.com
• fix: Fix to enums
• fix: Fix website build: update Docusaurus to 3.10.2, add @docusaurus/faster (#570)
• fix: Fixed from implementation
• fix: Fixed play-json naming issues (#422)
• fix: Merge branch 'master' into sonatype-fix
• fix: Merge pull request #266 from theiterators/fix/implementation_from_method
• fix: Merge pull request #281 from theiterators/crosspublish-fix
• fix: Merge pull request #484 from theiterators/sonatype-fix
• fix: Naming fix Enum -> Enums in Circe
• fix: Revert "move CaseClass1Rep to base module"
• fix: Scalafmt fix.
• fix: Slick trait visibility fix.
• …and 280 more

• 0 containers · 1 bounded contexts · 0 dependency edges (baseline)

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

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.