Constructing a REST API in Rust with Rhai and Actix Net

Rhai is a high-level scripting language that lets you write the logic of an software in scripts. These scripts can then be embedded into and executed inside Rust applications.

Since Rhai scripts are simpler to grasp than Rust, they’ll make it simpler to create extra advanced applications.

On this article, you’ll learn to embed Rhai scripts in Rust and construct RESTful APIs utilizing Rhai and the Actix Net framework, together with the next:

To comply with this text, you need to be aware of Rust, Rhai, and RESTful APIs.

What’s Rhai?

Rhai, or RhaiScript, is a small, quick, and embeddable scripting language that may be built-in into Rust applications. Rust applications can execute Rhai scripts whereas they’re working, which lets you implement advanced algorithms in an easy-to-understand script.

The identify “Rhai” was impressed by Chai, a scripting language for C++. Identical to Rhai will be embedded into Rust, Chai may also be embedded into C++, and lets you summary advanced algorithms in an easy-to-understand script.

ChaiScript and RhaiScript use JavaScript-like syntax. These scripting languages present a safe manner so as to add scripts to their respective programming languages.

Advantages of utilizing Rhai with Rust

Rhai has a number of advantages. For instance, Rhai scripts are sooner in comparison with different scripting languages for Rust, together with widespread choices like JavaScript, Lua, and Python. They’re additionally dynamically typed, which permits flexibility and reduces complexity.

As well as, Rhai is a higher-level language than Rust, which makes it simple for builders to implement advanced algorithms inside Rust applications. Rhai scripts can simply be embedded into Rust applications, work together with this system’s variables, and performance in a sandboxed surroundings.

Lastly, Rhai scripts are reminiscence protected and can’t have an effect on Rust applications. It is because they run in a managed surroundings and haven’t any potential to alter the surroundings exterior their sandbox.

Information to working Rhai scripts in Rust

To execute Rhai scripts in your Rust program, it is advisable comply with the steps under.

First, add the Rhai library to your Cargo.toml file:

[dependencies]
rhai = "1.6.1"

Subsequent, construct the challenge to obtain the library with the next command:

cargo construct

You additionally must have your Rust challenge arrange. You possibly can create an empty one utilizing the under command:

cargo init rhai_tutorial --bin

After constructing the challenge, you can begin writing your Rhai scripts. In our subsequent steps, we’ll arrange a “Hiya world” program as a easy instance of a Rust program utilizing a Rhai script.

First, copy the under to your foremost.rs file:

// import the scripting engine
use rhai::{ Engine };

fn foremost() {
    // Create the scripting engine
    let engine = Engine::new();

    // Run the script at "src/my_script.rhai"
    let end result = engine.eval_file::<String>("src/my_script.rhai".into()).unwrap();

    // print the outcomes of the script
    println!("{}", end result);
}

This system above executes the script we are going to create within the subsequent step, then print out the script’s returned worth.

Subsequent, create a brand new file named my_script.rhai within the src folder and replica the next into it. This script returns “Hiya, World!” again to Rust.

// a easy perform that appends "Hiya, "
// to the start of the argument
fn hi there(identify) {
    return "Hiya, " + identify;
}

// Rhai return the worth of the final expression
hi there("World!");

To run this program, write the Rust program within the src/foremost.rs file, and the Rhai script within the src/my_script.rhai file.

After creating the instance utilizing the steps above, run it with the next command:

$ cargo run
   Compiling rhai_tutorial v0.1.0 (..../rhai_tutorial)
    Completed dev [unoptimized + debuginfo] goal(s) in 19.09s
     Operating `goal/debug/instance`
Hiya, World!

Within the Rhai script, the hi there(); perform takes a string, appends "Hiya, " to the start of the string, after which returns the end result.

After Rust executes a Rhai script, it receives the worth of the final line of the script. On this instance, Rust receives “Hiya, World!” from the Rhai script and prints it to the terminal.

You may as well write Rust capabilities that may be known as from a Rhai script. That is helpful for creating Rhai scripts that want entry to some Rust performance. Let’s check out how one can accomplish this within the subsequent instance.

First, copy the under into your foremost.rs file:

// import the scripting engine
use rhai::{Engine};

fn foremost() {
    // Create scripting engine
    let mut engine = Engine::new();

    // create a hi there perform utilizing an nameless perform
>   let hi there = |identify: String| -> String {
>       let mut textual content = String::from("Hiya, ");
>       textual content.push_str(&identify);
>       return textual content;
>   };

    // register the perform within the engine
>   engine.register_fn("hi there", hi there);

    // Run the script at "my_script.rhai"
    let end result = engine.eval_file::<String>("src/my_script.rhai".into()).unwrap();

    // print the outcomes of the script
    println!("{}", end result);
}

Subsequent, copy the under into your my_script.rhai file:

// Rhai return the worth of the final expression
hi there("World!");

Now in the event you run this program, it is best to see “Hiya, World!” as earlier than. Nonetheless, as a substitute of writing the perform in your Rhai script, we achieved this by writing a Rust perform that was known as from the Rhai script.

Establishing the Actix Net framework for Rust

Representational state switch (REST) APIs are designed to facilitate communication between shoppers and servers. Since shoppers work independently from servers, they use APIs as an interface to ship and obtain requests.

The Actix Net framework is a generally used framework for constructing REST APIs. Rust internet frameworks present instruments that you just want to rapidly construct massive, scalable, and environment friendly REST APIs in Rust.

To arrange this framework, comply with the steps under.

First, add the dependency under into your challenge’s Cargo.toml file:

[dependencies]
actix-web = "4.0.1"

Subsequent, construct the challenge to obtain the library utilizing the command under.

cargo construct

After putting in the library, you may start to create RESTful APIs in Rust. To comply with together with the examples under, you need to be working in your foremost.rs file.

Easy Rust REST API instance utilizing Actix Net

The next is an easy instance of an API utilizing the Actix Net framework:

// import the the required modules from the library
use actix_web::{
  HttpServer,
  App,
  get,
  Responder,
};

// create a "https://weblog.logrocket.com/" route that
// responds with "Hiya, World"

#[get("https://blog.logrocket.com/")]
async fn greet() -> impl Responder {
  "Hiya, World!"
}

#[actix_web::main]
async fn foremost() -> std::io::Consequence<()> {
  // create the server
  HttpServer::new(|| {
    App::new()
      .service(greet)
  })
    .bind(("127.0.0.1", 8080))  // bind the server to localhost:8080
    .unwrap()                // unwrap the results of the bind trait
    .run()                    // run the server
    .await
}

Whenever you run the above program and make a request to http://localhost:8080/, it responds with “Hiya, World!”

Instance Rust REST API with a dynamic route

The under is one other instance of an API you may create utilizing this framework. On this instance, this system creates a dynamic route that claims “Hiya” to the worth of the parameter within the final phase of a URL:

use actix_web::{
  HttpServer,
  App,
  get,
  Responder,
  internet,
};

// in the event you ship a request to /customers, you get "Hiya, customers".

#[get("/{name}")]
async fn greet(path: internet::Path<(String, )>) -> impl Responder {
  // assign the primary of the trail's parameter to "identify"
  let identify = path.into_inner().0;

  // Append "Hiya, " to the start of the string, 
  // and return it
  format!("Hiya, {identify}!")
}

#[actix_web::main]
async fn foremost() -> std::io::Consequence<()> {
  HttpServer::new(|| {
    App::new()
      .service(greet)
  })
    .bind(("127.0.0.1", 8080))   // bind the server to localhost:8080
    .unwrap()                // unwrap the results of the bind trait
    .run()                    // run the server
    .await
}

Dynamic routes are routes which have a number of versatile URL segments. In Rust, you reference versatile segments by their place relative to different versatile segments. In Actix Net, this place makes use of a zero index: the primary happens at zero, and the second happens at one.

URL segments are a part of the route which might be between slashes. For instance, within the URL http://instance.com/path/to/useful resource, the segments are “path,” “to,” and “useful resource.”

Let’s say you despatched a request to this instance URL: http://localhost:8080/people

On account of this system we simply created, you’ll get a “Hiya, people!” response. It is because the final URL phase specifies “people,” which is then assigned to identify in this system.

Examples of the greet perform with a number of parameters

Let’s take our earlier instance a step additional. The next is an instance of the greet perform with one, two, or three parameters.

Let’s begin with a single parameter, as we did earlier than. Copy the code under into your file:

#[get("/{name}")]
async fn greet(path: internet::Path<(String, )>) -> impl Responder {
  let identify = path.into_inner().0;
  format!("Hiya, {identify}")
}

Now let’s use two parameters: identify and age. Substitute the contents of your file with the code under:

#[get("/{name}/{age}")]
async fn greet(path: internet::Path<(String, i32)>) -> impl Responder {
  let identify: String = path.into_inner().0;
  let age: i32 = path.into_inner().1;
  format!("Hiya, {identify} you're {age} years")
}

Now we’ll add a 3rd parameter: hair_color. For these three parameters, use the code under:

#[get("/{name}/{age}/{hair_color}")]
async fn greet(path: internet::Path<(String, i32, String)>) -> impl Responder {
  let identify: String = path.into_inner().0;
  let age: i32 = path.into_inner().1;
  let hair_color: String = path.into_inner().2;
  format!("Hiya, {identify} you're {age} with {hair_color} hair")
}

You possibly can have any variety of versatile segments on a single URL. This fashion, you may add logic to deal with routing that’s not recognized earlier than the API is working.

Utilizing REST APIs to increase advanced functionalities from Rust to run in Rhai

Rhai is an analysis engine, which implies you may’t run advanced functionalities, like database operations. To make use of these advanced functionalities, it is advisable lengthen them from Rust.

Within the following REST API challenge, the API and the routing are created utilizing Rust whereas Rhai handles the logic.

The libraries which might be used for constructing one of these API are actix-web and rhai. Observe the steps under to put in these libraries.

First, add the next dependencies to your challenge’s Cargo.toml file.

[dependencies]
actix-web = "4.0.1"
rhai = "1.6.1"

Subsequent, let’s construct the challenge. Set up the libraries within the challenge with the command under:

cargo construct

Now we’re able to get began.

Registering the challenge’s endpoints with Rust

The instance challenge on this part has two endpoints.

The endpoint /multiply/{num1}/{num2} is used for multiplying two numbers. For instance, in the event you ship a GET request to http://localhost:8080/multiply/5/10, you’ll get “50” because the response.

In the meantime, /add/{num1}/{num2} is used for including two numbers. Should you ship a GET request to http://localhost:8080/add/5/10, you’ll get “15” because the response.

This system under can be written in our foremost.rs file:

use actix_web::{
    HttpServer,
    get,
    App,
    internet::Path,
    Responder,
};
use rhai::Engine;

#[get("/multiply/{num1}/{num2}")]
async fn multiply(path: Path<(i64, i64)>) -> impl Responder {
    // get the numbers from the url path
    let (num1, num2) = path.into_inner();

    // create an occasion of the rhai engine
    let mut engine = Engine::new();

    // register an API that exposes the numbers to Rhai
    engine.register_fn("num1", transfer || num1);
    engine.register_fn("num2", transfer || num2);

    // run the script
    let end result = engine.eval_file::<i64>("src/multiply.rhai".into()).unwrap();

    // return the end result
    format!("{end result}")
}

#[get("/add/{num1}/{num2}")]
async fn add(path: Path<(i64, i64)>) -> impl Responder {
    // get the numbers from the url path
    let (num1, num2) = path.into_inner();

    // create an occasion of the rhai engine
    let mut engine = Engine::new();

    // register an API that exposes the numbers to Rhai
    engine.register_fn("num1", transfer || num1);
    engine.register_fn("num2", transfer || num2);

    // run the script
    let end result = engine.eval_file::<i64>("src/add.rhai".into()).unwrap();

    // return the end result
    format!("{end result}")
}

// When Rust executes the Rhai script, Rhai returns the results of the final expression

#[actix_web::main]
async fn foremost() -> std::io::Consequence<()> {

    HttpServer::new(|| {
        App::new()
            .service(multiply)
            .service(add)
    })
        .bind(("127.0.0.1", 8080))
        .unwrap()
        .run()
        .await
}

After copying the code above, now you can use the multiply and add capabilities within the Rhai engine. Create two recordsdata within the src folder:

• multiply.rhai, which performs the logic of the /multiply route.
• add.rhai, which performs the logic of the /add endpoint

Copy the next script into the multiply.rhai file:

fn multiply(num1, num2) {
  return num1 * num2;
}

let num1 = num1();
let num2 = num2();

multiply(num1, num2);

Copy the next script into the add.rhai file:

fn add(num1, num2) {
  return num1 + num2;
}

let num1 = num1();
let num2 = num2();

add(num1, num2);

After compiling and executing the Rust program, take a look at the outcomes by opening up an instance similar to http://localhost:8080/add/5/15 in your browser. This instance ought to lead to one thing just like the under:

Conclusion

On this article, we lined creating Rhai scripts, constructing backend APIs utilizing Actix Net, and utilizing Rhai scripts in backend APIs.

Rhai is a really useful gizmo for constructing Rust applications, which helps builders to put in writing advanced code within the simpler to grasp script, and might then be embedded into the Rust applications.

Check out the Github repo for the ultimate challenge on this article to test or evaluate your work. Should you’re desirous about studying extra on this matter, learn The Rhai Guide or be taught how one can create a backend API with Rust.

I hope you discovered this text helpful. Thanks for studying!