/claim #519

Hi team,

Due to GitHub’s file size constraints for video uploads, please find the recording of the successful local test run here: . This covers the JVM and MessagePack module validation.

I’ve implemented the schema migration system as described in issue #519. This adds support for evolving schemas over time while maintaining backward and forward compatibility.

The implementation follows the two-layer architecture from the spec:

Migration[A, B] provides the type-safe API that developers use. Under the hood, DynamicMigration handles the actual transformations using pure, serializable data structures. This means migrations can be versioned and applied offline without needing the original code.

All the required migration operations are included:

• Record operations: addField, dropField, renameField, transformField
• Field modifiers: mandateField, optionalizeField, changeFieldType
• Enum operations: renameCase, transformCase
• Collection operations: transformElements, transformKeys, transformValues

The builder API uses macros to validate field selectors at compile time, so you get errors early if you reference a field that doesn’t exist. It works with both Scala 2.13 and 3.3+.

I spent some time on the error handling - when something goes wrong, you get the full path context showing exactly where in the nested structure the problem occurred.

For reversibility, operations like rename are fully reversible, while things like mandate require you to provide a default value for the reverse direction. The system enforces this at compile time.

Testing was thorough - 45+ test cases covering all the operations, composition, edge cases, and both Scala versions. Full test suite takes about 35 minutes but everything passes cleanly.

I have two videos showing the tests running:

1. Individual test execution
2. Full clean test run with both Scala versions

I’ll upload those in the next comment.

A few implementation notes:

Past schema versions use structural types, so you don’t need to keep old case classes around in your production code. The expression language (SchemaExpr) handles primitive transformations in a serializable way. Everything is zero-dependency as per the project philosophy.

Let me know if you’d like me to adjust anything or if you have questions about the implementation.

Thanks for reviewing!