set the channel description: The expressive validation library, designed for complex business logic.

cleared channel description

set the channel description: Official place to discuss about the validation library Akkurate https://akkurate.dev

Welcome to this new community channel 👋 Ask all the questions you have about Akkurate, I will answer you ASAP!

Hi! Its been quite some time since the last release, because the new one is about a complex subject: Generics! ✨ Akkurate 0.3.0 is now available and brings essentially two things: • Full support for generic types. You were already able to apply constraints on generic types (like

List<String>

) but now you can also create a generic class and apply the

@Validate

annotation on it. • Built-in accessors for basic Kotlin types. Now you can easily access and validate properties of many Kotlin types. You want to access the keys of a

Map

? Just write

keys

and apply the constraints you want on it. A lot of new ideas came to me while working on this release, expect a roadmap update soon!

Just wondering, would it be feasable to reuse Arrow Optics with Akkurate somehow? I mean for accessors.

I can't seem to add to

Support generating accessors for 3rd party types

in the roadmap any comments... but I think that's one of the main blockers for me to make my own adapter for Strikt in my unit tests, because I don't really want to annotate my production code with

@Validate

when I'm only using it in test code... it seems like the typealias might help for that...

Truth is, if I'd create a Fixture data class in my test code that includes classes from my production code, and I annotate only it with

@Validate

, would Akkurate generate all the accessors for the classes it refers to @Johann Pardanaud?

About 3rd party types, actually this is just not documented yet, but it's already possible through a KSP plugin option! You just have to provide a list of FQCN to the validatableClasses option.

Any reason why

implementation("dev.nesk.akkurate:akkurate-ksp-plugin:0.3.0")

has to be included as

implementation

? It's only the ksp plugin, no? I haven't seen that in other ksp libs AFAIK...

yes, its because the

@Validate

annotation is part of the KSP plugin, which is why you need it as an implementation too

How do you validate on a List (doesn't seem like there's a section in the docs on this -- and it also seems that there's no specialized matchers list for this scope...)?

val validateInstallActionList = dev.nesk.akkurate.Validator<List<InstallAction>> {
   // ....?        
}

(notice that Intellij had troubles importing

Validator

...?)

It would also be nice to have isEqualExceptForProperties(foo, prop2, prop3) // props list is vararg

Btw, the source code doesn't seem to be available when ctrl-clicking something in akkurate from my code... is there something missing when you upload to maven?

Hello, I saw yesterday's annoucement of akkurate and took a quick glance at it. I was wondering why you've chosen to implement your own

ValidationResult

class instead of e.g. using Arrow's

Either

. I guess the latter would make for a better interoperability.

Just thinking out loud... maybe the Arrow adapter shouldn't just translate a ValidationResult to Either, but rather provide it's own

.bind()

and function with

Raise

that returns the success's value, or raises the error or exception... but then maybe both error types should be encapsulated in their own sealed interface? That would avoid the overhead of having to convert to Either just to bind or raise etc...

Akkurate *0.4.0* just got released! ✨ In summary: • The documentation is now searchable 🔍 • New constraints to validate JVM dates • Validating nullable iterables just got easier:

Validator<List<Any>?> { each { ... } }

• The configuration of a

Validator

has been revamped to a DSL builder. What to expect in the next weeks 🦠 • Better documentation: Kdoc for every public symbol, and server validation tutorials • The first integration in a long series: arrow Arrow

The first tutorial is finally available! Discover how to do server-side validation with Akkurate 🎯 and Ktor ktor Let me know what you think about it. 🙇‍♂️ Is it too long? Too complex? Or is it missing some things? I want to know 🙂

Thanks for the recent tutorial @Johann Pardanaud. One gap I see with using data classes in API interfaces is that immutable strongly-typed data classes aren't often a great fit for receiving "messy" data at the API level. For example, if a value is required, it has to be given a "default value" -- in your tutorial you used an empty String, but that introduces some noise into the data model. Furthermore, errors can be thrown in advance of validation -- kotlinx-serialization may not even be able to create the data class if the types or fields don't match. Also, implementing capabilities like

PATCH

is impossible to do with the same types, because the incoming data is incomplete, so even if the server-side code can deserialize it (unlikely), we still need to know which subset of fields was actually sent by the client. I had implemented https://github.com/rocketraman/kpropmap to deal with these scenarios in the past. The idea is to receive the data from the API in a flexible way, and then do validation and conversion to the strongly typed model on the server-side. Any thoughts on introducing a similar capability to Akkurate? I've long wanted, but haven't had the time to have kpropmap use KSP and kotlinx-serialization rather than runtime reflection, and Akkurate already uses these tools.

I've started to work on the missing KDoc for all the library symbols, it will take some time but its on the right track. kodee happy Each constraint will contain a code example in its documentation, see `hasSizeEqualTo()` for example. Expect more documentation in the following weeks. You can keep track of the progression on GitHub issues.

(also, Arrow's integration is on the way arrow)

Akkurate 0.5.0 just got released! 🥳 This is a really small release, essentially it contains: • A new configuration option to fail on the first constraint violation • More documented symbols with KDoc • Some improvements on the online documentation Now it's time for Arrow's integration 💪