hemera

Removed dependencies lodash, hoek and fastparellel and use built-in functions.

I'm really happy to announce the new Hemera 5 release!

This release is a ground-breaking refactoring of the core. The goal was to simplify but also make the lifecycle of extensions and middlwares more predictable.

In summary:

• Refactor extension lifecycle and handling
• Refactor plugin management
• Simplify payload validator and codec interface
• Brand new Documentation with https://docusaurus.io/

Breaking changes:

• Removed Reply.end()
• Removed hemera.root property
• Removed Hemera.reply() in favor of hemera.reply.next() to send multiple responses in a row
• Removed configuration properties crashOnFatal, shouldCrash. The developer is responsible to catch these errors
• Removed CodecPipeline
• Removed encoder, decoder. We provide setter functions for client and server encoding
• Remove support to register multiple plugins at once with hemera.use
• Remove plugin$, plugins property, remove hemera.setOption(), hemera.setConfig() methods
• Remove functionality to to send a response inside serverPreResponse. This was confusing because the payload is already set at this point
• Load plugins only on hemera.ready() not when hemera.use() is called
• We break the support of simple return values in add or middlewares without the use of callback or promises

New features:

• Implement schemaCompiler to archive better abstraction for payload validators
• Support for async schemaCompiler
• Encapsulate extensions, codec and schemaCompiler
• Provide setter functions for client and server encoding

Modified packages

• hemera-joi Remove post validation
• Remove support for hemera-nsq and hemera-controlplane
• hemera-plugin you can skip the creation of a plugin scope with scoped:false

Bug fixes

• Fixed issue in add middleware. Passed errors didn't lead to cancellation

Breaking changes

• Use of callback-style with act(...) won't return a promise anymore rather undefined
• Use of promise-style with act(...) will return to a fulfilled promise a context object with two properties data and context. On a rejection, only the error is returned.
  • data message response
  • context hemera instance with the right meta$, context$ and trace$ informations.

Migration Guide

Don't mix callback and promise style and work in case of promise with the result object

Before

const result = await hemera.act({
  topic: "math",
  cmd: "add"
}, async function (err, resp) {
	// code ...
})

After with promise

const result = await hemera.act({
  topic: "math",
  cmd: "add"
})
// code ...
result.data
result.context

After with callback

hemera.act({
  topic: "math",
  cmd: "add"
}, function (err, resp) {
	// code ...
})

• Support of custom parent span via context$
• Remove hemera version from span tags
• Use pattern as span operation name
• Add HEMERA_OP_TYPE, HEMERA_ACT_EXPECTEDMSG and HEMERA_CONTEXT tags

• Refactor tracing
• Fixed tracing propagation

• Implement onAdd extensions https://github.com/hemerajs/hemera/pull/188
• Expose matchedAction which represent the matched action behind the pattern

• Add promise support for close method
• Stop emitting close errors rather pass them via callback or promise style

• Upgrade to latest NATS driver
• Upgrade Pino logger
• Implement expectedMessages$ flag https://github.com/hemerajs/hemera/pull/185
• Update docs
• Make request-reply sid inside act-context public

Add promise support for hemera.ready() when no callback is passed.

• Upgrade nats-hemera dependencies
• Upgrade dev-dependencies from Repository

Upgrade avvio to v5.1

Throw error when hemera was already boostraped

• Allow hemera to be ready even when the nats connection was already established

• Introduce hemera.reply([Error, any]) to reply multiple message. Don't call cb multiple times.

• Don't close hemera when an error listener was registered

Execute onClose hook and gracefully shutdown hemera on synchronous uncaught error

Improvements

• Don't swallow synchronous uncaught errors, let them handle by the user. This is needed to identify the real error during testing. If you add an hemera.on('error') listener all errors are caught. (Default behavior of an event-emitter)
• Gracefully shutdown nats and process when calling fatal()

Breaking Changes

• Any synchronous uncaught error will exit the process except you define an hemera.on('error') listener or catch it manually. If you use promises or async / await then it has no effect.

• Use same way in all cases to handle the end of a request lifecycle.
• Update doc

• Support async, promise and raw values in middlewares
• Clean up code, remove unused functions and tests
• Avoid calling action when calling reply.end(<msg>) in middlewares

• add When no callback is provided any returned value is accepted as a result.