type of the parent module
The factory of the module, i.e. its including namespace
Module's cache, usually initialized at module construction (except if one is provided at construction).
The module's static configuration.
See ModuleConfiguration for a discussion about static vs dynamic configuration.
Environment, used to:
A dictionary of helping objects (often functions) that can be used when writing an adaptor for the module.
the list of inputSlots, those have to be registered at module's construction.
🤓 The number of inputs, and what they do, can depend on the module's configuration
The list of available journals.
This includes:
❕ Only the latest Journal for a particular Journal.title attribute is kept in memory.
The channels of logs broadcasting, by default:
Observable that emits the logs of the module.
module id, if not provided explicitly at construction it is a uuidv4
the list of inputSlots, those have to be registered at module's construction.
🤓 The number of outputs, and what they do, can depend on the module's configuration
Add an input to the module.
The contract: defines pre-conditions and data normalization in order to reach the triggered process
description of the process triggered by the input when incoming data comes in. If not provided, 'no description available' is used.
id - usually a meaningful name that is not shared with other inputs/outputs. If not provided, 'input' is used.
❕ if multiple inputs are added you need to provide an id to them
The callback triggered when a message reach the input
The method addOutput declares a new output for the module and return a handle (Pipe) to emit value at any time.
An output is usually used in such way:
export class Module extends ModuleFlux {
result$ : Pipe<number>
constructor( params ){
super(params)
this.addInput({
id:'input',
description: 'trigger an operation between 2 numbers',
contract: expectCount<number>( {count:2, when:permissiveNumber}),
onTriggered: ({data, configuration, context}) =>
this.do(data, configuration, context)
})
this.result$ = this.addOutput({id:'result'})
}
do( data: [number, number], configuration: PersistentData, context: Context ) {
let result = operationsFactory[configuration.operationType](data)
context.info('Computation done', {result})
this.result$.next({data:result,context})
}
}
Couple of comments:
id - usually a meaningful name that is not share with other inputs/outputs. If not provided 'output' is used.
A pipe that allows to emit data
the slot id
Matching input slot; undefined if not found
the slot id
Matching output slot; undefined if not found
This function return the default PersistentData of the module. The default data can be updated at run time: the updated version is then provided to the 'onTriggered' callback defined in addInput method.
Default persistent data
the slot id
Matching input or output slot; undefined if not found
Log a message with data in the 'console' ('console' is exposed in the environment).
Generated using TypeDoc
PluginFlux
Base class for plugins in Flux: a ModuleFlux that can interact with a parent module.
All the rules/usages of modules also apply here. The difference with a module is that plugins implementation, constructor or methods, can make use of the parent module.
Do not forget to cleanup you stuffs 😬
It is common that the plugin has some side effect(s) on its the parent module, in this case the plugin need to implement the SideEffects trait. Indeed the parent module can outlive the plugin in flux application: a proper definition of SideEffects.apply and SideEffects.dispose is needed for flux to properly work.