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 💪

Feel free to give me some feedback about Arrow's integration 🙂 https://kotlinlang.slack.com/archives/C5UPMM0A0/p1701862293655069

🎉 In release 0.6.0, Akkurate akkurate finally supports #arrow arrow https://akkurate.dev/docs/arrow-integration.html

set the channel topic: akkurate The expressive validation library https://akkurate.dev

Just thinking... maybe it would be a good idea to have a variant of

Validator { }

that generates a

Raise<NonEmptySet<ConstraintViolation>>.() -> T

that way it could be used in an either without

toEither()

and

bind(..)

?

Long time no see! Akkurate 0.7.0 is finally released 🥳 So, why did it took so much time for such a small release? I'm currently starting my own company (unrelated to Akkurate) and it takes a lot of time and work, which means I didn't have much time for Akkurate at the end. 😅

Akkurate 0.8.0 has been released! akkurate What's new? ✨ You can now transform values before validating them, perfect for normalization:

hashtags.each {
    // Trim hashtags for leading "#", and only then ensure that it's not empty
    map { it.trimStart('#') }.isNotEmpty()
}

New constraints:

// Validate the type of a value
someValue.isInstanceOf<String>()

// Validate elements are unique in a collection
someCollection.hasNoDuplicates()

It is now easier than ever to validate a specific index of a collection:

someCollection.first().isNotEmpty()
someCollection.last().isNotEmpty()
someCollection[index].isNotEmpty()

What's next? 🔜 Probably Kotlin 2.0 and KMP 😏

I have two questions: (1) why is there an

@Validate

annotation given that Kotlin tries to avoid them (and the reflection based control flows that result from them) over explicit call chains; and (2) is it possible to inspect the validation constrains (in other words: are the validation constrains "just data" so we can write programs that, for instance, add a

max-length=X

attribute a HTML form element if there is a maxLength constraint on the field that backs up the form element)?

Apparently I've found the issue and a fix, let me run additional checks, write tests, and release everything 🙂

I've forgot to tell you, you can also use `map` to transform your data before validating it:

map { it.map { it.id } }
    .hasNoDuplicates()

In response to popular request: the built-in constraints are now listed on a single page kodee floating

akkurate Akkurate 0.10.0 has been released kodee happy In this release, you'll find: • New constraints for kotlinx-datetime • A new artifact to test your custom constraints And an official integration for Ktor is coming soon! ktor new

@Johann Pardanaud Akkurate works really well in our project. Thank you for solving our problem! ❤️

I have a question, and I have no other place to ask it than here... I wonder if anyone has also run into this, or maybe even has an answer for this. Say we have a dto that backs a form submission:

data class Person(val name: String?, val dateOfBirth: LocalDate?) {
  fun validate(): ValidationResult { ... }
}

When we submit an empty form

name

and

dateOfBirth

are

null

. Say this is fine for

dateOfBirth

(it's not a required field) and

name

fails validation. So we present the user with the validation errors and allow 'm to try again. Now user submits again with a

name

and the dto validates. Only all the required fields (in this case only one) are still nullable! So mapping the dto to db records (we use jOOQ for that) we have a lot of `!!`s, i.e.

record.name = dto.name!!

. Ideally I'd like the validate method to return a

ValidatedPerson

data class which has all required fields marked as non-nullable. And the only way I can imagine to have this, is by doing A LOT of boiler plate: defining the ``ValidatedPerson`` myself, mapping to it by hand, etc. This is so much work that I rather do the `!!`s on the mapping to the record. Like I said: just curious is you are doing something similar to me, or have found another way to handle this.

kodee happy https://x.com/kotlin/status/1857095650355130469

kodee excited https://kotlinlang.slack.com/archives/C0BJ0GTE2/p1733838977631739

Hi! I am trying to test this library. But it seems like i cannot get the variable (property) from data class? From the docs i should get this ..?

@Johann Pardanaud AFAIK

otherwise { }

only supports strings right? It's not so great when validating forms in Jetpack Compose where an error is an R.string.XXX (an Int...)... any chance of expanding that to support other types?

Question: why is the

@Validate

annotation needed?

Hi there. @Johann Pardanaud is there an ability to take a single validation for a property? I'm working on an example with akkurate for Spring Boot + Angular to share DTOs and validations and wondering if I can have something like this:

@Validate
data class Book(val title: String)

val bookValidator = Validator<Book> { // this: Validatable<Book>
    title.hasLengthLowerThan(50)
}

val titleValidator = bookValidator::title // Validator.Runner<String>