scala-commons

Changes in REST framework:

• support for application/x-www-form-urlencoded through @FormBody annotation on REST methods
• OpenApi now supports arbitrary JSON values for default values in schemas, enums and examples
• Default values from @whenAbsent annotation on method parameters and case class parameters are included into generated OpenAPI documents
• @example annotation for REST parameters to define example values later included into OpenAPI document

Other changes:

• MacroGenerated now accepts typed companion which may inject implicits into macro materialization
• Applier and Unapplier typeclasses
• annotations materialized using @reifyAnnot and @reifyEncodedAnnot can accept parameters annotated as @infer which will be inferred by macro engine as implicits

Changes in REST framework:

• Added support for OpenAPI 3.0 specification generation
• DefaultRestApiCompanion and DefaultRestServerApiCompanion require materialization of OpenApiMetadata which requires RestSchema instances for data types used in REST API traits.
• 204 No Content status code is used for empty responses instead of 200 OK.

Changes in RPC macro engine:

• introduced metadata generation for ADTs (algebraic data types)
• extracted common RPC & ADT meta-annotations to meta package from rpc package and renamed some of them
• RPC method declaration order is honored, first matching raw method is taken
• @annotated[A] filtering meta-annotation for RPC methods and parameters
• metadata parameters now must always be annotated to tell the macro engine how to materialize them - introduced @rpcMethodMetadata, @rpcParamMetadata, @adtCaseMetadata and @adtParamMetadata meta-annotations
• metadata parameters now have limited support for sealed hierarchies of metadata classes

Other changes:

• JsonOptions now aggregates some of its fields in JsonFormatting object, added afterColon formatting option
• commons-annotations module now depends on commons-macros
• JSON serialization improvements by @plokhotnyuk - #83
• various new extension methods in SharedExtensions

• configurable AsyncContext timeout in JettyRPCFramework
• async higher order extensions for collections
• worked around a compiler bug where sealed hierarchy computation in macros didn't work for some traits loaded from classfiles

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

• silencer updated to 1.1 in order to fix #75

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).

• 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.

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

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

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

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

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.

• 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

ValueEnum

ValueEnum is a new way for defining Scala enums, representing enum constants as final vals in companion object of enum class.

Advantages:

• feature parity with Java enums (although ValueEnum does not extend java.lang.Enum)
• every enum constant has name (name of the final val that declares the constant) and ordinal (zero based index of enum constant, consistent with declaration order).
• less boilerplate than sealed hierarchy based enums
• it's possible to declare many enum constants in a single line of code
• much less generated classes, which is advantageous primarily for JS size reduction

Disadvantages:

• scalac exhaustive pattern match checking does not understand ValueEnum which may result in both lack of correct warnings and incorrect warnings
• each enum constant can't have its own API (unless through implicit classes)

Optimizations for JS size reduction

Serialization framework:

• completely refactored macro-generated GenCodecs for much less generated code by moving as much code as possible to base classes: ApplyUnapplyCodec, ProductCodec, SealedHierarchyCodec etc.
• performance optimizations based on benchmarks in comparison with Circe

RPC framework:

• reduced amount of code generated for macro-materialized instances of AsRawRPC, AsRealRPC
• dropped RPCTypeClasses in favor of newly introduced RPCFramework#RPCCompanion which is designed so that DCE removes unused TC instances

commons-core full cross project

• Modules commons-shared (previously cross compiled to JVM and JS) and commons-core (previously JVM only) have been merged into a single cross compiled module commons-core. Therefore you must replace your dependencies to commons-shared with commons-core.
• Removed BasicJavaInterop, implemented JavaInterop separately for JS (without Java 8 stuff which is unavailable in ScalaJS)

RPC framework has been generalized to allow other types of remote methods than getters, functions and procedures. Old functionality of RPCFramework is retained as StandardRPCFramework, which is now a special case of new, generalized RPCFramework. RPCMetadata has also been adjusted to reflect the generalization.

These changes are not backwards compatible.

• first public release

• RPCMetadata typeclass

• hocon-spring has been moved to commons-spring module