moleculer-rs — work in progress

Inspired and compatible with Moleculer JS

You can currently do all the basics of emit, broadcast and call.

However it only works with the NATS transporter and JSON serializer/deserializer.

Getting Started

Available on crates: crates.io/moleculer

toml moleculer = "0.2.0"

Simple example showing how to receive an event, and responding to a request, for more check the examples folder

```rust use std::error::Error; use moleculer::{ config::{ConfigBuilder, Transporter}, service::{Context, Event, EventBuilder, Service}, ServiceBroker, }; use serde::Deserialize;

[tokio::main]

async fn main() -> eyre::Result<()> { envlogger::init(); coloreyre::install()?;

// build config
let config = ConfigBuilder {
    transporter: Transporter::nats("nats://localhost:4222"),
    ..ConfigBuilder::default()
}
.build();

// create the first event
let print_hi = EventBuilder::new("printHi").add_callback(print_hi).build();

// create the second event
let print_name = EventBuilder::new("printName")
    .add_callback(print_name)
    .build();

// create math action
let math_action = ActionBuilder::new("mathAdd").add_callback(math_add).build();

// create a service with events and actions
let greeter_service = Service::new("rustGreeter")
    .add_event(print_hi)
    .add_event(print_name)
    .add_action(math_action);

// create service broker with service
let service_broker = ServiceBroker::new(config).add_service(greeter_service);

// start the service broker
service_broker.start().await;

Ok(())

}

// callback for first event, will be called whenever "printHi" event is received fn printhi(ctx: Context) -> Result<(), Box> { println!("Hello from Rust"); Ok(()) }

// callback for second event, will be called whenever "printName" event is received fn printname(ctx: Context) -> Result<(), Box> { let msg: PrintNameMessage = serdejson::from_value(ctx.params)?;

println!("Hello to: {} from Rust", msg.name);

Ok(())

}

// callback for math action fn mathadd(ctx: Context) -> Result<(), Box> { // get message decode using serde let msg: ActionMessage = serdejson::from_value(ctx.params.clone())?; let answer = msg.a + msg.b;

// serialize reply using serde and send reply
let _ = ctx.reply(answer.into());

Ok(())

}

[derive(Deserialize)]

struct PrintNameMessage { name: String, }

[derive(Deserialize)]

struct ActionMessage { a: i32, b: i32, } ```

Current Status

What it does

Big missing pieces: