v1.32.0

Changes in RPC/ADT macro engines:

• @reifyEncodedAnnot removed, allowed @composite parameters to be @optional instead
• introduced @reifyDefaultValue for reifying Scala-level default values of case class fields
• introduced overloadedOnly flag for @rpcNamePrefix which causes it to be used only for overloads of RPC methods
• introduced ImplicitNotFound typeclass for customizing implicit-not-found compilation errors for arbitrary types

REST framework:

• support for headers in HTTP responses (requires custom serialization to RestResponse)
• automatic handling of HEAD and OPTIONS requests
• operationId in generated Operation objects now defaults to RPC methods plain name, without the HTTP method prefix (e.g. soSomething instead of post_doSomething) unless the method is overloaded.
• nicer compilation error messages for various missing REST-related implicits
• @operationIdPrefix annotation for prefix methods
• operation adjusters can now be specified for prefix methods - will apply to all operations under a prefix method
• introduced new type of adjuster: PathItemAdjuster for adjusting OpenAPI PathItem objects
• introduced new adjuster annotations: @operationId, @nullable, @tags, @bodyDescription, @responseDescription, @pathDescription, @summary, @pathSummary, @title, @schemaDescription
• configurable async context timeout and buffer size for Jetty-based client & server
• OpenAPI generation now accepts predefined Components
• various minor fixes and improvements

GenCodec:

• compilation errors raised for missing dependencies are positioned on case class parameters which cause these errors
• GenCodec.Auto removed

v1.31.0

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

v1.30.0

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

v1.29.1

• 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

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.