What's new in Kuzzle ? Winter release 2019

Good morning, everyone!

I hope you all had a great holiday and are ready for the new year 2019, which promises to be a busy one for Kuzzle!

Here in Montpellier winter is already almost over but despite the short days we have not been idle!

🇫🇷 See this article in French: https://blog.kuzzle.io/fr/la-winter-release-2019-de-kuzzle

Kuzzle

Integration of the MQTT protocol into the core

The core of Kuzzle is now in version 1.6. This minor release sees the arrival of MQTT protocol support directly in the core and no longer through a plugin.

As the demand for this protocol is growing, we preferred to integrate it directly into Kuzzle in order to simplify the task for IoT application developers.

The protocol is disabled by default, to enable it you need to modify your configuration in your kuzzlerc:

{
  "server": {
    "protocols": {
      "mqtt": {
        "enabled": true
      }
    }
  }
}

Support for Elasticsearch aliases

Kuzzle is now able to recognize and use the Elasticsearch aliases.

Although it can use them like other indexes, their creation must be done directly through the Elasticsearch API.

Javascript SDK exposed in plugins

We decided to expose the SDK JS 6 in the plugins context. This special version of the SDK uses a special protocol directly connected to the core of Kuzzle instead of going through the network layer.

This way plugin developers will be able to enjoy the same development convenience as client application developers by using the high-level features of the SDK.

// With old execute() syntax
const request = new this.context.constructors.Request({
 controller: 'document',
 action: 'create',
 index: 'blackmesa',
 collection: 'lambda-core',
 body: { gordon: 'freeman' }
});
await this.context.accessors.execute(request);

// With the embedded SDK
await this.context.accessors.sdk.document.create(
 'blackmesa',
 'lambda-core',
 { gordon: 'freeman' }
);

Using functions for hooks and pipes

It is now possible to use directly functions for hooks, pipes or controller action in plugins.

Until now it was only possible to pass a string corresponding to a function of the plugin object.

this.hooks = {
 'document:afterCreate': (...args) => this.myFunction(...args)
};

this.pipes = {
 'document:afterGet': (...args) => this.restrictUser(...args)
};

this.controllers = {
 newController: {
   myAction: (...args) => this.myAction(...args)
 }
};

Kuzzle Plugin Advanced Boilerplate

A new boilerplate for plugins is available.

It allows developers to quickly start developing a plugin while respecting best practices, including concern separation and unit testing.

This is the basis for most of the Kuzzle plugins we develop for our customers.

For more details, see the README on Github

New documentation

After months of writing and refining, the new version of our documentation is finally ready!

This new version has been developed entirely in a customized way with metalsmith in order to best meet our needs.

The biggest changes are a complete redesign of the API, the plugin system and Koncorde documentation, the documentation of the latest version of our SDKs with a maximum of code examples and an Algolia search available on all documentation.

Finally, we have written Getting Started in Javascript, Go, C++ and Java to make it easier to use our SDK's.

Feel free to take a look, who knows it may be the day to finally get started on Go? ;)

News from Kuzzle SDK’s

This winter we have made a lot of progress on the latest version of our SDKs and we are very excited to finally be able to release them officially.

Official release of SDK JS 6

After months of beta testing, the latest version of our Javascript SDK has finally been officially released.

We advise all developers to use this version if it was not already the case!

If you were using a beta version of the SDK JS 6, remember to check the breakings changes, among other things:

Change of signature of the document:create method
Instantiating the SDK with a Protocol class
realtime:subscribe method return value

You can now integrate the latest version of the SDK by simply doing so:

> npm install kuzzle-sdk

First Community SDKs: Dart and Rust

For the first time external contributors have developed SDKs for Kuzzle.

We were very pleased to see that the Dart/Flutter community is also interested in Kuzzle, and we would particularly like to thank @prijindal and @stafyniaksacha for their work on the SDK Dart!

On his side, @alexandrebouthinon of the Kuzzle team has also made a new SDK in Rust in his spare time! We hope that the Rust community will be happy to know that they can now use Kuzzle more easily thanks to the high level API offered by this SDK.

You can now consult the new SDK listing page on our documentation: https://docs.kuzzle.io/sdk-reference/

The documentation for these SDKs is not yet available but they are very similar to the Javascript SDK and scrupulously follow the architecture of our API in terms of controllers and actions as well as the different parameters.

Javascript/Go/C++/Java: Instantiation with a Protocol class

SDKs are now instantiated directly with a Protocol class.

Thus responsibilities are better separated between the Protocol which ensures communication with Kuzzle and the SDK which manages the functionalities of the offline mode.

This evolution is one of the last breaking changes before the final release of the SDKs.

// Javascript
const kuzzle = new Kuzzle(
  new WebSocket('localhost')
);

// C++
using namespace kuzzleio;

kuzzleio::Kuzzle *kuzzle = new kuzzleio::Kuzzle(
  new kuzzleio::WebSocket("localhost")
);

// Golang
kuzzle, _ := kuzzle.NewKuzzle(websocket.NewWebSocket("kuzzle"), nil)

Javascript: Compatibility with React Native

We are pleased to announce that the Javascript SDK is now fully compatible with the latest version of React Native!

The use of Symbol was a problem for older versions, this is now fixed.

Go/C+++/Java: Memory and stability leak hunting

In order to improve the robustness of our SDKs, we have searched and fixed all memory leaks in our C and C++ wrappers.

These memory leaks were also responsible for the random crashes of the SDK's.

Now the C++ functional tests are launched with Valgrind to ensure that no memory leaks are present in the SDK.

This is a very important step before the final release because now the SDK's derived from C++ are starting to be stable enough to be used in production.

Kuzzle <3 Vue.js

Those who know us know that we swear almost exclusively by Vue.js to develop frontend applications.

The Admin Console is a perfect example of the symbiosis between a frontend in.js View and a backend with Kuzzle.

We are currently working on a Getting Started specially for Vue.js, as well as a full How-To on the development of a Todo MVC application with Kuzzle and Vue.js.

Boilerplate Vue.js and CoreUI

We also use CoreUI a lot to make it easier for us to develop IoT applications, so we created a boilerplate using Vue.js, CoreUI and the JS 6 SDK.

https://github.com/kuzzleio/kuzzle-vuejs-coreui-boilerplate

This boilerplate includes user authentication, connection loss management, internationalization with I18N and an example of end-to-end testing with Cypress.