What's Changed

• feat(TS/cachers): add types for lock functions by @thib3113 in https://github.com/moleculerjs/moleculer/pull/1152
• Typing add spanName and safeTags to tracing options by @thib3113 in https://github.com/moleculerjs/moleculer/pull/1157
• Use interface instead of type to allow for declaration merging by @shawnmcknight in https://github.com/moleculerjs/moleculer/pull/1165
• Prevent registerInternalServices deprecation warning by @DenisFerrero in https://github.com/moleculerjs/moleculer/pull/1163

New Contributors

• @DenisFerrero made their first contribution in https://github.com/moleculerjs/moleculer/pull/1163

Full Changelog: https://github.com/moleculerjs/moleculer/compare/v0.14.26...v0.14.27

What's Changed

Changes

• fix typescript definitions for the Service class #1139
• allow matching hooks to multiple actions with "|" #1149
• fix serializers datetime flaky test #1151

New Contributors

• @sabadoryo made their first contribution in https://github.com/moleculerjs/moleculer/pull/1148
• @SKarajic made their first contribution in https://github.com/moleculerjs/moleculer/pull/1139
• @someone635 made their first contribution in https://github.com/moleculerjs/moleculer/pull/1149
• @sorattorafa made their first contribution in https://github.com/moleculerjs/moleculer/pull/1151

Full Changelog: https://github.com/moleculerjs/moleculer/compare/v0.14.25...v0.14.26

Changes

• fix Node 19 compatibility

Full Changelog: https://github.com/moleculerjs/moleculer/compare/v0.14.24...v0.14.25

Changes

• allow moleculer-runner to resolve configuration files from node_modules #1126
• fixed slower broker startup time issue #1132
• fixed memory leak at dynamic service creation #1121
• fixed invalid 'undefined' type in validator schema. #1137
• update dependencies

Changes

• fixed timeout issue in waitForServices method #1123
• fixed metadata issue when compression enabled #1122

35 commits from 11 contributors.

Changes

• fixed 'Ctx is undefined when using shard strategy and preferLocal is false, throws error on emit' #1072
• fixed info packet send at broker stop #1101
• added support for either-or versions to waitForServices #1030
• fixed streaming issue with compression #1100
• add requestID to debug logs in transit #1104
• removed static on methods for the use of ServiceFactory #1098
• fixed the issue with setting tracing and metrics options with env variables #1112
• added dependencyTimeout broker option #1118
• improved d.ts #1099 #1111 #1115
• updated dependencies

20 commits from 2 contributors.

ESM support #1063

This version contains an ESM-based Moleculer Runner. This Runner is able to load ESM configuration file and ESM services. It can load the CJS services, as well

Example usage

moleculer-runner-esm --repl services/**/*.service.mjs

Moreover, the index.js file is wrapped into index.mjs, so you can import internal modules from the core in ESM modules. E.g.:

import { ServiceBroker, Errors } from "moleculer";

Please note, the hot-reload function doesn't work with this ESM Runner. The cause: https://github.com/nodejs/modules/issues/307 Node maintainers try to solve the missing features (module cache and module dependency tree) with loaders but this API is not stable yet.

Other Changes

• broker.stopping property is created to indicate that broker is in stopping state.

52 commits from 8 contributors.

Dependency logic changed #1077

In mixed architecture, it's not hard to create a circular service dependency that may cause a dead-lock during the start of Moleculer nodes. The problem is that Moleculer node only sends the local service registry to remote nodes after all local services started properly. As of 0.14.20, this behavior has changed. The new logic uses a debounced registry sending method which is triggered every time a local service, that the node manages, has started().
Note that the new method generates more INFO packets, than early versions, during the start of the node. The number of INFO packets depends on the number of the services that the node manages. The debounce timeout, between sending INFO packets, is 1 second.

Other Changes

• fix ActionLogger and TransitLogger middlewares.
• update Datadog Logger using v2 API. #1056
• update dependencies.
• update d.ts file. #1064, #1073
• fix pino child logger bindings. #1075

69 commits from 7 contributors.

Custom error recreation feature #1017

You can create a custom Regenerator class which is able to serialize and deserialize your custom errors. It's necessary when the custom error is created on a remote node and must be serialized to be able to sent back to the caller.

Create a custom Regenerator

const { Regenerator, MoleculerError } = require("moleculer").Errors;

class TimestampedError extends MoleculerError {
    constructor(message, code, type, data, timestamp) {
        super(message, code, type, data);
        this.timestamp = timestamp;
    }
}

class CustomRegenerator extends Regenerator {
    restoreCustomError(plainError, payload) {
        const { name, message, code, type, data, timestamp } = plainError;
        switch (name) {
            case "TimestampedError":
                return new TimestampedError(message, code, type, data, timestamp);
        }
    }
    extractPlainError(err) {
        return {
            ...super.extractPlainError(err),
            timestamp: err.timestamp
        };
    }
}
module.exports = CustomRegenerator;

Use it in broker options

// moleculer.config.js
const CustomRegenerator = require("./custom-regenerator");
module.exports = {
    errorRegenerator: new CustomRegenerator()
}

Error events #1048

When an error occured inside ServiceBroker, it's printed to the console, but there was no option that you can process it programatically (e.g. transfer to an external monitoring service). This feature solves it. Every error inside ServiceBroker broadcasts a local (not transported) event ($transporter.error, $broker.error, $transit.error, $cacher.error, $discoverer.error) what you can listen in your dedicated service or in a middleware.

Example to listen in an error-tracker service

module.exports = {
    name: "error-tracker",

    events: {
        "$**.error": {
            handler(ctx) {
                // Send the error to the tracker
                this.sendError(ctx.params.error);
            }
        }
    }
}

Example to listen in a middleware or in broker options

module.exports = {
    created(broker) {
        broker.localBus.on("*.error", payload => {
            // Send the error to the tracker
            this.sendError(payload.error);
        });
    }
}

Wildcards in Action Hooks #1051

You can use * wildcard in action names when you use it in Action Hooks.

Example

hooks: {
    before: {
        // Applies to all actions that start with "create-"
        "create-*": [],
        
        // Applies to all actions that end with "-user"
        "*-user": [],
    }
}

Other Changes

• update dependencies.
• update d.ts file. #1025, #1028, #1032
• add safetyTags option to tracing exporters. #1052

20 commits from 7 contributors.

Changes

• update dependencies.
• expose Cacher and Validator middlewares. #1012
• update d.ts file. #1013
• parse user & password from NATS server urls. #1021

61 commits from 10 contributors.

Changes

• reformat codebase with Prettier.
• fix binding issue in Pino logger. #974
• update d.ts file. #980 #970
• transit message handler promises are resolved. #984
• fix cacher issue if cacher is not connected. #987
• fix Jest open handlers issue. #989
• fix cacher cloning issue. #990
• add custom headers option to Zipkin trace exporter. #993
• fix heartbeatTimeout option in BaseDiscoverer. #985
• add cacher keygen option action definition. #1004
• update dependencies

11 commits from 4 contributors.

Changes

• fix nats-streaming version in peerDependencies.
• RedisCacher pingInterval option. #961
• Update NATS transporter messages to debug. #963
• update d.ts file. #964 #966
• update dependencies

15 commits from 5 contributors.

Changes

• fix nats version in peerDependencies.
• convert url to servers in nats@2. #954
• add typing for mcall settled option. #957
• revert TS ThisType issue in 0.14.14. #958
• update dependencies
• add useTag259ForMaps: false default option for CBOR serializer to keep the compatibility.

105 commits from 11 contributors.

New CBOR serializer #905

CBOR (cbor-x) is a new serializer but faster than any other serializers.

Example

// moleculer.config.js
module.exports = {
    logger: true,
    serializer: "CBOR"
};

Benchmark

Suite: Serialize packet with 10bytes
√ JSON               509,217 rps
√ Avro               308,711 rps
√ MsgPack             79,932 rps
√ ProtoBuf           435,183 rps
√ Thrift              93,324 rps
√ Notepack           530,121 rps
√ CBOR             1,016,135 rps

   JSON (#)            0%        (509,217 rps)   (avg: 1μs)
   Avro           -39.38%        (308,711 rps)   (avg: 3μs)
   MsgPack         -84.3%         (79,932 rps)   (avg: 12μs)
   ProtoBuf       -14.54%        (435,183 rps)   (avg: 2μs)
   Thrift         -81.67%         (93,324 rps)   (avg: 10μs)
   Notepack        +4.11%        (530,121 rps)   (avg: 1μs)
   CBOR           +99.55%      (1,016,135 rps)   (avg: 984ns)

settled option in broker.mcall

The broker.mcall method has a new settled option to receive all Promise results. Without this option, if you make a multi-call and one call is rejected, the response will be a rejected Promise and you don't know how many (and which) calls were rejected.

If settled: true, the method returns a resolved Promise in any case and the response contains the statuses and responses of all calls.

Example

const res = await broker.mcall([
    { action: "posts.find", params: { limit: 2, offset: 0 },
    { action: "users.find", params: { limit: 2, sort: "username" } },
    { action: "service.notfound", params: { notfound: 1 } }
], { settled: true });
console.log(res);

The res will be something similar to

[
    { status: "fulfilled", value: [/*... response of `posts.find`...*/] },
    { status: "fulfilled", value: [/*... response of `users.find`...*/] },
    { status: "rejected", reason: {/*... Rejected response/Error`...*/} }
]

New MOLECULER_CONFIG environment variable in Runner

In the Moleculer Runner, you can configure the configuration filename and path with the MOLECULER_CONFIG environment variable. It means, no need to specify the config file with --config argument.

Supporting [email protected] in NATS transporter

The new nats 2.x.x version has a new breaking API which has locked the NATS transporter for [email protected] library. As of this release, the NATS transporter supports both major versions of the nats library.

The transporter automatically detects the version of the library and uses the correct API.

Async custom validator functions and ctx as metadata

Since [email protected], the FastestValidator supports async custom validators and you can pass metadata for custom validator functions. In Moleculer, the FastestValidator passes the ctx as metadata. It means you can access to the current context, service, broker and you can make async calls (e.g calling another service) in custom checker functions.

Example

// posts.service.js
module.exports = {
    name: "posts",
    actions: {
        params: {
            $$async: true,
            owner: { type: "string", custom: async (value, errors, schema, name, parent, context) => {
                const ctx = context.meta;

                const res = await ctx.call("users.isValid", { id: value });
                if (res !== true)
                    errors.push({ type: "invalidOwner", field: "owner", actual: value });
                return value;
            } }, 
        },
        /* ... */
    }
}

Changes

• fix node crash in encryption mode with TCP transporter. #849
• expose Utils in typescript definition. #909
• other d.ts improvements. #920, #922, #934, #950
• fix etcd3 discoverer lease-loss issue #922
• catch errors in Compression and Encryption middlewares. #850
• using optional peer dependencies. #911
• add relevant packet to to serialization and deserialization calls. #932
• fix disabled balancer issue with external discoverer. #933

Changes (62 commits from 12 contributors)

• update dependencies
• logging if encryption middleware can't decrypt the data instead of crashing. #853
• fix disableHeartbeatChecks option handling. #858
• force scanning only master redis nodes for deletion. #865
• add more info into waitForServices debug log messages. #870
• fix EVENT packet Avro schema. #856
• fix array & date conversion in cacher default key generator. #883
• fix Datadog tracing exporter. #890
• better elapsed time handling in tracing. #899
• improve type definitions. #843, #885, #886
• add E2E tests for CI (test all built-in transporter & serializers)

Other changes

• update dependencies
• improved type definitions. #816 #817 #834 #840
• support rediss:// cacher URI. #837
• fix Event Trace exporter generated events loop. #836
• change log level of node disconnected message. #838
• improve the broker.waitForServices response. #843
• fix recursive hot-reload issue on Linux OS. #848

New merged service lifecycle hook

Service has a new merged lifecycle hook which is called after the service schemas (including mixins) has been merged but before service is registered. It means you can manipulate the merged service schema before it's processed.

Example

// posts.service.js
module.exports = {
    name: "posts",

    settings: {},

    actions: {
        find: {
            params: {
                limit: "number"
            }
            handler(ctx) {
                // ...
            }
        }
    },

    merged(schema) {
        // Modify the service settings
        schema.settings.myProp = "myValue";
        // Modify the param validation schema in an action schema
        schema.actions.find.params.offset = "number";
    }
};

Other changes

• add requestID tag to all action and event spans #802
• fix bug in second level of mixins with $secureSettings #811

Changes

• update dependencies
• fix issues in index.d.ts
• fix broadcast event sending issue when disableBalancer: true #799 (thanks for @ngraef)

Register method in module resolver

If you create a custom module (e.g. serializer), you can register it into the built-in modules with the register method. This method is also available in all other built-in module resolver.

Example

// SafeJsonSerializer.js
const { Serializers } = require("moleculer");

class SafeJsonSerializer {}

Serializers.register("SafeJSON", SafeJSON);

module.exports = SafeJsonSerializer;

// moleculer.config.js
require("./SafeJsonSerializer");

module.exports = {
    nodeID: "node-100",
    serializer: "SafeJSON"
    // ...
});

Changeable validation property name

You can change the params property name in validator options. It can be useful if you have a custom Validator implementation.

const broker = new ServiceBroker({
    validator: {
        type: "Fastest",
        options: {
            paramName: "myParams" // using `myParams` instead of `params`
        }
    }
});

broker.createService({
    name: "posts",
    actions: {
        create: {
            myParams: {
                title: "string"
            }
        },
        handler(ctx) { /* ... */ }
    }
});

Global tracing span tags for actions & events

Thanks for @kthompson23, you can configure the action & events tracing span tags globally. These tags will be used for all actions & events where tracing is enabled. Of course, you can overwrite them locally in the action & event schema.

Example

// moleculer.config.js
module.exports = {
    tracing: {
        enabled: true,
        exporter: 'Zipkin',
        tags: {
            action: {
                meta: ['app.id', 'user.email', 'workspace.name'],
                params: false,  // overrides default behavior of all params being adding as tags
                response: true,
            },
            event: (ctx) {
                return {
                    caller: ctx.caller,
                }
            }  
        }
    }
}

Other changes

• fix multiple trace spans with same ID issue in case of retries.
• update dependencies
• add lastValue property to histogram metric type.
• update return type of context's copy method.
• add configuration hotReloadModules #779
• Remove Zipkin v1 annotations and change kind to SERVER

Github Sponsoring is available for Moleculer :tada:

We have been approved in Github Sponsors program, so you can sponsor the Moleculer project via Github Sponsors. If you have taxing problem with Patreon, change to Github Sponsors.

New Validator configuration

The validator has the same module configuration in broker options like other modules. It means you can configure the validation constructor options via broker options (moleculer.config.js).

Default usage:

//moleculer.config.js
module.exports = {
    nodeID: "node-100",
    validator: true // Using the default Fastest Validator
}

Using built-in validator name:

//moleculer.config.js
module.exports = {
    nodeID: "node-100",
    validator: "FastestValidator" // Using the Fastest Validator
}

Example with options:

//moleculer.config.js
module.exports = {
    nodeID: "node-100",
    validator: {
        type: "FastestValidator",
        options: {
            useNewCustomCheckerFunction: true,
            defaults: { /*...*/ },
            messages: { /*...*/ },
            aliases: { /*...*/ }
        }
    }
}

Example with custom validator

//moleculer.config.js
const BaseValidator = require("moleculer").Validators.Base;

class MyValidator extends BaseValidator {}

module.exports = {
    nodeID: "node-100",
    validator: new MyValidator()
}

New metrics

Added the following new metrics:

• moleculer.event.received.active: Number of active event executions.
• moleculer.event.received.error.total: Number of event execution errors.
• moleculer.event.received.time: Execution time of events in milliseconds.
• os.memory.total: OS used memory size.

Other changes

• support using moleculer.config.js with export default.
• remove some lodash methods.
• upgrade to the latest tsd.
• new dependencyInterval broker option. Using as default value for broker.waitForServices #761
• fix Datadog traceID, spanID generation logic to work with latest dd-trace.
• add error stack trace to EventLegacy trace exporter.
• fix INFO key issue in Redis Discoverer after Redis server restarting.

New Discoverer module

The Discoverer is a new built-in module in Moleculer framework. It's responsible for that all Moleculer nodes can discover each other and check them with heartbeats. In previous versions, it was an integrated module inside ServiceRegistry & Transit modules. In this version, the discovery logic has been extracted to a separated built-in module. It means you can replace it to other built-in implementations or a custom one. The current discovery & heartbeat logic is moved to the Local Discoverer.

Nevertheless, this version also contains other discoverers, like Redis & etcd3 discoverers. Both of them require an external server to make them work. One of the main advantages of the external discoverers, the node discovery & heartbeat packets don't overload the communication on the transporter. The transporter transfers only the request, response, event packets. By the way, the external discoverers have some disadvantages, as well. These discoverers can detect lazier the new and disconnected nodes because they scan the heartbeat keys periodically on the remote Redis/etcd3 server. The period of checks depends on the heartbeatInterval broker option.

The Local Discoverer (which is the default) works like the discovery of previous versions, so if you want to keep the original logic, you'll have to do nothing.

Please note the TCP transporter uses Gossip protocol & UDP packets for discovery & heartbeats, it means it can work only with Local Discoverer.

Local Discoverer

It's the default Discoverer, it uses the transporter module to discover all other moleculer nodes. It's quick and fast but if you have too many nodes (>100), the nodes can generate a lot of heartbeat packets which can reduce the performance of request/response packets.

Example

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: "Local"
    }    
}

Example with options

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: {
            type: "Local",
            options: {
                // Send heartbeat in every 10 seconds
                heartbeatInterval: 10,

                // Heartbeat timeout in seconds
                heartbeatTimeout: 30,

                // Disable heartbeat checking & sending, if true
                disableHeartbeatChecks: false,

                // Disable removing offline nodes from registry, if true
                disableOfflineNodeRemoving: false,

                // Remove offline nodes after 10 minutes
                cleanOfflineNodesTimeout: 10 * 60
            }
        }
    }    
}

Redis Discoverer

This is an experimental module. Do not use it in production yet!

This Discoverer uses a Redis server to discover Moleculer nodes. The heartbeat & discovery packets are stored in Redis keys. Thanks to Redis key expiration, if a node crashed or disconnected unexpectedly, the Redis will remove its heartbeat keys from the server and other nodes can detect it.

Example to connect local Redis server

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: "Redis"
    }    
}

Example to connect remote Redis server

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: "redis://redis-server:6379"
    }    
}

Example with options

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: {
            type: "Redis",
            options: {
                redis: {
                    // Redis connection options.
                    // More info: https://github.com/luin/ioredis#connect-to-redis
                    port: 6379,
                    host: "redis-server",
                    password: "123456",
                    db: 3
                }

                // Serializer
                serializer: "JSON",

                // Full heartbeat checks. It generates more network traffic
                // 10 means every 10 cycle.
                fullCheck: 10,

                // Key scanning size
                scanLength: 100,

                // Monitoring Redis commands
                monitor: true,
                
                // --- COMMON DISCOVERER OPTIONS ---

                // Send heartbeat in every 10 seconds
                heartbeatInterval: 10,

                // Heartbeat timeout in seconds
                heartbeatTimeout: 30,

                // Disable heartbeat checking & sending, if true
                disableHeartbeatChecks: false,

                // Disable removing offline nodes from registry, if true
                disableOfflineNodeRemoving: false,

                // Remove offline nodes after 10 minutes
                cleanOfflineNodesTimeout: 10 * 60
            }
        }
    }    
}

To be able to use this Discoverer, install the ioredis module with the npm install ioredis --save command.

Tip: To further network traffic reduction, you can use MsgPack/Notepack serializers instead of JSON.

Etcd3 Discoverer

This is an experimental module. Do not use it in production yet!

This Discoverer uses an etcd3 server to discover Moleculer nodes. The heartbeat & discovery packets are stored in the server. Thanks to etcd3 lease solution, if a node crashed or disconnected unexpectedly, the etcd3 will remove its heartbeat keys from the server and other nodes can detect it.

Example to connect local etcd3 server

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: "Etcd3"
    }    
}

Example to connect remote etcd3 server

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: "etcd3://etcd-server:2379"
    }    
}

Example with options

// moleculer.config.js
module.exports = {
    registry: {
        discoverer: {
            type: "Etcd3",
            options: {
                etcd: {
                    // etcd3 connection options.
                    // More info: https://mixer.github.io/etcd3/interfaces/options_.ioptions.html
                    hosts: "etcd-server:2379",
                    auth: "12345678"
                }

                // Serializer
                serializer: "JSON",

                // Full heartbeat checks. It generates more network traffic
                // 10 means every 10 cycle.
                fullCheck: 10,
                
                // --- COMMON DISCOVERER OPTIONS ---

                // Send heartbeat in every 10 seconds
                heartbeatInterval: 10,

                // Heartbeat timeout in seconds
                heartbeatTimeout: 30,

                // Disable heartbeat checking & sending, if true
                disableHeartbeatChecks: false,

                // Disable removing offline nodes from registry, if true
                disableOfflineNodeRemoving: false,

                // Remove offline nodes after 10 minutes
                cleanOfflineNodesTimeout: 10 * 60
            }
        }
    }    
}

To be able to use this Discoverer, install the etcd3 module with the npm install etcd3--save command.

Tip: To further network traffic reduction, you can use MsgPack/Notepack serializers instead of JSON.

Custom Discoverer

You can create your custom Discoverer. We recommend to copy the source of Redis Discoverer and implement the necessary methods.

Other changes

• fixed multiple heartbeat sending issue at transporter reconnecting.
• the heartbeatInterval default value has been changed to 10 seconds.
• the heartbeatTimeout default value has been changed to 30 seconds.
• the heartbeat check logics use process uptime instead of timestamps in order to avoid issues with time synchronization or daylight saving.
• Notepack serializer initialization issue fixed. It caused problem when Redis cacher uses Notepack serializer.
• new removeFromArray function in Utils.
• mcall method definition fixed in Typescript definition.
• dependencies updated.

New NewRelic zipkin tracing exporter

Thanks for @jalerg, there is a NewRelic tracing exporter. PR #713

// moleculer.config.js
{
    tracing: {
        enabled: true,
        events: true,
        exporter: [
            {
                type: 'NewRelic',
                options: {
                    // NewRelic Insert Key
                    insertKey: process.env.NEW_RELIC_INSERT_KEY,
                    // Sending time interval in seconds.
                    interval: 5,
                    // Additional payload options.
                    payloadOptions: {
                        // Set `debug` property in payload.
                        debug: false,
                        // Set `shared` property in payload.
                        shared: false,
                    },
                    // Default tags. They will be added into all span tags.
                    defaultTags: null,
                },
            },
        ],
    },    
}

Other changes

• fix stream chunking issue. PR #712
• fix INFO packet sending issue after reconnecting
• safely handling disconnected state for transporters (heartbeat queuing issue). PR #715
• fix orphan response issue in case of streaming with disabled balancer. #709
• update dependencies, audit fix

Wrapping service methods with middlewares

New localMethod hook in middlewares which wraps the service methods.

Example

// my.middleware.js
module.exports = {
    name: "MyMiddleware",

    localMethod(next, method) {
        return (...args) => {
            console.log(`The '${method.name}' method is called in '${method.service.fullName}' service.`, args);
            return handler(...args);
        }
    }
}

Schema for service methods

Similar for action schema, you can define service methods with schema. It can be useful when middleware wraps service methods.

Example for new method schema

// posts.service.js
module.exports = {
    name: "posts",

    methods: {
        list: {
            async handler(count) {
                // Do something
                return posts;
            }
        }
    }
};

Changes

• add chunk limit for streams in message transporting. #683
• add baseUrl option to Datadog metric reporter. #694
• fix open handles in unit tests. #695
• update d.ts #699 #700 #703

Changes

• add stop method to tracing exporters. Fixes #689
• fix EventLegacy tracing exporter. Fixes #676
• the defaultTags property in tracer options can be a Function, as well.

Changes

• fix issue in AMQP 1.0 transporter

Support custom loggers

If you have your custom logger you should wrap it into a Logger class and implement the getLogHandler method.

Using a custom logger

// moleculer.config.js
 const BaseLogger = require("moleculer").Loggers.Base;

class MyLogger extends BaseLogger {
    getLogHandler(bindings) {
        return (type, args) => console[type](`[MYLOG-${bindings.mod}]`, ...args);
    }
}

module.exports = {
    logger: new MyLogger()
};

Changes

• fix bluebird import issue #674

:tada: First 0.14 stable version. Full changelog: https://github.com/moleculerjs/moleculer/blob/master/CHANGELOG.md#0140-2020-02-12

Migration guide: https://github.com/moleculerjs/moleculer/blob/master/docs/MIGRATION_GUIDE_0.14.md

Changes since 0.14.0-rc2

AMQP 1.0 transporter

Thanks for @vladir95, AMQP 1.0 transporter is available.

Please note, it is an experimental transporter. Do not use it in production yet!

// moleculer.config.js
module.exports = {
    transporter: "amqp10://activemq-server:5672"
};

To use this transporter install the rhea-promise module with npm install rhea-promise --save command.

Transporter options

Options can be passed to rhea.connection.open() method, the topics, the queues, and the messages themselves.

Connect to 'amqp10://guest:guest@localhost:5672'

// moleculer.config.js
module.exports = {
    transporter: "AMQP10"
};

Connect to a remote server

// moleculer.config.js
module.exports = {
    transporter: "amqp10://activemq-server:5672"
};

Connect to a remote server with options & credentials

// moleculer.config.js
module.exports = {
    transporter: {
        url: "amqp10://user:pass@activemq-server:5672",
        eventTimeToLive: 5000,
        heartbeatTimeToLive: 5000,
        connectionOptions: { // rhea connection options https://github.com/amqp/rhea#connectoptions, example:
            ca: "", // (if using tls)
            servername: "", // (if using tls)
            key: "", // (if using tls with client auth)
            cert: "" // (if using tls with client auth)
        },
        queueOptions: {}, // rhea queue options https://github.com/amqp/rhea#open_receiveraddressoptions
        topicOptions: {}, // rhea queue options https://github.com/amqp/rhea#open_receiveraddressoptions
        messageOptions: {}, // rhea message specific options https://github.com/amqp/rhea#message
        topicPrefix: "topic://", // RabbitMq uses '/topic/' instead, 'topic://' is more common
        prefetch: 1
    }
};

Redis Cluster feature in Redis transporter

Thanks for AAfraitane, use can connect to a Redis Cluster with the Redis transporter.

Connect to Redis cluster

// moleculer.config.js
module.exports = {
    transporter: {
        type: "Redis",
        options: {
            cluster: {
                nodes: [
                    { host: "localhost", port: 6379 },
                    { host: "localhost", port: 6378 }
                ]
            }
        }
    }
};

AMQP 1.0 transporter

Thanks for @vladir95, AMQP 1.0 transporter is available.

Please note, it is an experimental transporter. Do not use it in production yet!

// moleculer.config.js
module.exports = {
    transporter: "amqp10://activemq-server:5672"
};

To use this transporter install the rhea-promise module with npm install rhea-promise --save command.

Transporter options

Options can be passed to rhea.connection.open() method, the topics, the queues, and the messages themselves.

Connect to 'amqp10://guest:guest@localhost:5672'

// moleculer.config.js
module.exports = {
    transporter: "AMQP10"
};

Connect to a remote server

// moleculer.config.js
module.exports = {
    transporter: "amqp10://activemq-server:5672"
};

Connect to a remote server with options & credentials

// moleculer.config.js
module.exports = {
    transporter: {
        url: "amqp10://user:pass@activemq-server:5672",
        eventTimeToLive: 5000,
        heartbeatTimeToLive: 5000,
        connectionOptions: { // rhea connection options https://github.com/amqp/rhea#connectoptions, example:
            ca: "", // (if using tls)
            servername: "", // (if using tls)
            key: "", // (if using tls with client auth)
            cert: "" // (if using tls with client auth)
        },
        queueOptions: {}, // rhea queue options https://github.com/amqp/rhea#open_receiveraddressoptions
        topicOptions: {}, // rhea queue options https://github.com/amqp/rhea#open_receiveraddressoptions
        messageOptions: {}, // rhea message specific options https://github.com/amqp/rhea#message
        topicPrefix: "topic://", // RabbitMq uses '/topic/' instead, 'topic://' is more common
        prefetch: 1
    }
};

Redis Cluster feature in Redis transporter

Thanks for AAfraitane, use can connect to a Redis Cluster with the Redis transporter.

Connect to Redis cluster

// moleculer.config.js
module.exports = {
    transporter: {
        type: "Redis",
        options: {
            cluster: {
                nodes: [
                    { host: "localhost", port: 6379 },
                    { host: "localhost", port: 6378 }
                ]
            }
        }
    }
};

Changes

• fix action hooks merging issue