v1.29.0

Primary motivation for this release is RPC based REST framework
The biggest breaking change is change of serialization format used by GenCodec for Option - migrate carefully!

Changes in RPC framework itself (mostly inspired or needed by REST framework):

• Raw parameters and metadata parameters may be grouped into classes using @composite
• Method RPC name no longer needs to be the only parameter in first parameter list of @multi raw methods. Now it can appear anywhere in the raw method signature but it must be explicitly marked as @methodName. It may also be inside a @composite parameter.
• @methodTag and @paramTag now accept default tag value instead of type. This value is injected as effective annotation on real methods/params so there's no need to worry about default tags in annotation processing.
• @tagged now accepts whenUntagged parameter containing tag value assumed when real method/param is untagged. This fallback tag value is also injected as effective annotation on real method/param.
• Brought back requirement that RPC name must be unique among all methods in RPC trait and among all parameters in RPC method.
• Introduced @rpcNamePrefix which may be aggregated by method/param tags to effectively allow overloading RPC methods as long as they have different tags.
• Introduced @tried - raw method annotation which causes results of real methods to be automatically wrapped into Try. This catches possible exceptions thrown by real methods and makes it possible to handle them during serialization to raw values.
• Implemented reusable infrastructure for easy creation of base companion classes for RPC traits.
• RPC framework now understands @transientDefault on RPC method parameters
• Raw methods in RPCFramework (legacy RPC) now accept a single RawInvocation parameter that aggregates method name and argument list.

Changes in annotation processing:

• Introduced @defaultsToName meta-annotation for String-typed annotation parameters.

Changes in serialization (mostly breaking, #74):

• Option no longer serializes to a list - it uses the same format as Opt, i.e. None is represented as null and Some(null) is indistinguishable from None - it will deserialize as None. Input and Output implementations may fall back to the old list-based format by overriding legacyOptionEncoding method.
• JsonStringInput and JsonStringOutput now accept JsonOptions - #66. Default serialization of timestamps has changed to emit ISO-formatted UTC-based millisecond-precision timestamp string. Default serialization of byte arrays has changed to emit JSON arrays of numbers instead of HEX strings.
• Removed InputType and replaced it with simple isNull method on Input
• @transparent codecs now delegate null deserialization to its underlying codec instead of returning bare null value.

Other unrelated features:

• Introduced general purpose Timestamp class
• JettyRPCFramework client now accepts responses bigger than 2MiB - #77

v1.28.3

• silencer updated to 1.1 in order to fix #75

v1.28.2

Introduced TypeString and JavaClassName - platform-independent, serializable, macro-generated typeclasses that hold full textual representation of a Scala type (TypeString) and fully qualified class name of a Java class corresponding to a Scala type (JavaClassName).

v1.28.1

• Introduced SealedUtils.instancesFor macro which lists instances of some typeclass for every case class (non-abstract subclass) of a sealed hierarchy
• Introduced @showAst annotation which works similarly to .showAst extension macro but can be used on definitions (classes, objects, members) instead of just expressions. However, it requires commons-analyzer compiler plugin to be enabled.

v1.28.0

Generalized RPC framework - #57

This is an overhaul of RPC macro engine and overall RPC design. Compatibility with previous version is not preserved but RPCFramework is kept as legacy glue code. Porting old usages of RPCFramework to new version should be relatively easy as incompatibilities are not big:

• Signature of raw methods (fire, call and get) has changed - it takes RPC name in separate parameter list and arguments as List[RawValue] instead of List[List[RawValue]]
• RPCMetadata API changed - there is separate metadata map for every method type (procedure, function, getter).

Changes in GenCodec and serialization

Breaking changes:

• HasGenCodec redesigned. MacroCodec[T] removed in favor or MacroGenerated[GenCodec[T]]. HasGenCodec is now more flexible - previously it didn't work for case classes with default parameter values or sealed traits with subclasses in companion object. This was caused by overzealous validation done by the compiler on super constructor arguments - they cannot refer to the object being constructed. Materialization of MacroGenerated is now able to work around this.
• GenCodec.Auto has been deprecated and will be removed
• Input and Output now support BigInt and BigDecimal natively - #69

Other changes:

• @whenAbsent for providing default values for case class parameters used only during deserialization
• Macro materialization works sealed refined types - #67
• Macro materialization works for case classes with more than 22 parameters - #62
• Fixed recursive materialization of flat sealed hierarchies - #63

v1.27.8: Merge branch 'redis-init-rc-fix' into HEAD

Fixed race condition in RedisClusterClient initialization that caused it to sometimes not initialize at all.

v1.27.1

Breaking changes:

• Field order preservation requirement for Input/Output has been relaxed - instead of preserving field order, ObjectInput may provide implement (override) peekField for random field access

v1.27.0

Breaking changes:

• BsonRef is now parameterized by entity type and also wraps an actual getter from entity type to referred type
• Automatic GenCodec for Map[K,V] that uses list-of-key-value-pairs encoding (where no GenKeyCodec[K] is available) has been removed

v1.25.3

New features in commons-spring

• ScalaParameterNameDiscoverer - a ParameterNameDiscoverer implementation which uses Java 8 reflection to obtain parameter names or falls back to Scala runtime reflection when under older Java or when parameter names are not present in bytecode
• ScalaDefaultValuesInjector - a BeanFactoryPostProcessor implementation which injects default values of Scala constructor and factory method arguments into bean definitions if they are lacking.

v1.25.2

• GuavaUtils trait renamed to GuavaInterop, its companion object extends it
• JavaInterop no longer mixes in GuavaUtils
• dependency on Guava in commons-core (JVM) is optional