Kuzzle - inter-plugins communication (via method calls)

Question

Is there a way with Kuzzle, to make two plugins communicate with each other?

Let's say a plugin A wants to call a method of a plugin B at boot time, or even runtime for some use cases. How can I do that ?

For now, there is no way to retrieve a particular plugin instance from another plugin. Plugins manager isn't reachable at plugin initialization, but in some way via a Kuzzle request (not the proper way of doing it)

function (request) {
    const kSymbol = Object.getOwnPropertySymbols(request.context.user)[0];

    request.context.user[kSymbol].pluginsManager.MyPlugin.someMethod(...args);

    ...
}

The idea behind this question would be to do something like this, when initializing the plugin

function init (customConfig, context) {
    const { pluginsManager } = context;

    const result = pluginsManager.MyPlugin.someMethod(...args);

    // make something with the result ?

    // For later use of plugins manager perhaps ?
    this.context = context
}

Looks like Kuzzle Pipes would be the right thing to do it, cause they are synchronous and chainable, but pipes don't return anything when triggering an event

function init (customConfig, context) {
    const result = context.accessors.trigger('someEvent', {
        someAttribute: 'someValue'
    });

    console.log(result) // undefined
}

Thanks for your help !

Answer 1

full disclosure: I work for Kuzzle

Even if accessing the pluginManager like this may work at this time, we may change the internal implementation without warning since it's not documented so your plugin may not work in next version of Kuzzle.

The easiest way to use a feature from another plugin is exposing a new API method through a custom controller and then call it with the query method of the embedded SDK.

For example if your plugin name is notifier-plugin in the manifest:

this.controllers = {
  email: {
    send: request => { /* send email */ }
  }
};

Then you can call it in another plugin like this:

await this.context.accessors.sdk.query({ 
  controller: 'notifier-plugin/email', 
  action: 'send'
});

Please note that you can't make API calls in the plugin init method.

If you need to make API calls when Kuzzle start, then you can add a hook/pipe on the core:kuzzleStart event.

this.hooks = {
  'core:kuzzleStart': () => this.context.accessors.sdk.query({ 
     controller: 'notifier-plugin/email', 
     action: 'send'
  });
};

Finally I noticed that you can't use pipes returns like in your example but I have proposed a feature to allow plugin developers to use the pipe chain return.

It will be available in the next version of Kuzzle.