Converting a REST API from Node.js and Express to Rust

22 Dec, 2022

Do you want to improve the performance and scalability of your REST API? Well, converting a REST API developed with Node.js and Express to Rust can be a great way to improve the performance and scalability of your application, for sure!

But why Rust? Rust is a systems programming language known for its speed, safety, and concurrency, making it well-suited for building high-performance APIs. Also, we can use the Actix web framework, which is a lightweight and flexible web framework for Rust that offers a simple and easy-to-use API, async support, and extensibility. By combining Rust and Actix web, we can build reliable, high-performance APIs that are able to handle a large number of requests concurrently and scale to meet the needs of our users.

Let’s now take a simple example of a REST API written in Node.js using the Express framework. Later, we will convert this API to Rust:

const express = require('express');
const app = express();

app.use(express.json());

app.post('/', (req, res) => {
  const user = req.body;
  res.json(user);
});

app.listen(8080, () => {
  console.log('API listening on port 8080');
});

This API has a single endpoint that accepts a POST request with a JSON body, and returns the JSON data in the response.

Now, let’s see how we can convert this API to Rust!

Setting up your Rust environment

To get started, you’ll need to have Rust and its package manager, Cargo, installed on your machine. You can find installation instructions for Rust at the official Rust website.

Once you have Rust and Cargo set up, you’ll need to create a new Rust project using Cargo. To do so, open a terminal and navigate to the directory where you want to create your project. Then, run the following command:

cargo new my-new-api --bin

This will create a new Rust project called “my-new-api” with a binary executable as the target. Of course, you need to replace “my-new-api” with the name of the API you want to convert from Express to Rust.

Adding dependencies for your Rust API

Next, you’ll need to add the dependencies for your API. To do this, open the Cargo.toml file in the root of your project and add the following lines:

[dependencies]
actix-web = "3.0"
serde = { version = "1.0", features = ["derive"] }
serde_json = "1.0"

These dependencies will provide you with the necessary tools for building a REST API in Rust, including the Actix web framework, the Serde library for serialization and deserialization, and the Serde JSON library for working with JSON data.

As we mentioned before, Actix web is a lightweight and flexible web framework for Rust. It was originally built on top of the Actix actor system, but it is now largely unrelated to the actor framework and is built using a different system. Actix web offers a simple and easy-to-use API for building web applications and APIs, and features such as routing, middleware, async support, and extensibility.

That’s said, Actix Web is perfect for converting a REST API from Express to Rust, as it provides all the features that we typically find in a Node.js Express application. So let’s get started!

Writing the code for your API

Now that you have your dependencies set up, you can start writing the code for your API. To do this, open the main.rs file in the root of your project and add the following code:

use actix_web::{web, App, HttpResponse, HttpServer, Result};
use serde::{Deserialize, Serialize};

#[derive(Serialize, Deserialize)]
struct User {
    name: String,
    age: i32,
}

async fn index(user: web::Json<User>) -> Result<HttpResponse> {
    Ok(HttpResponse::Ok().json(user.0))
}

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    HttpServer::new(|| {
        App::new()
            .route("/", web::post().to(index))
    })
    .bind(("127.0.0.1", 8080))?
    .run()
    .await
}

This code defines a simple REST API with a single endpoint that accepts a POST request with a JSON body. The JSON body is deserialized into a User struct, which is then serialized and returned in the response.

Testing your API

To test your API, you can start the server by running the following command in your terminal:

cargo run

Then, you can send a POST request to the / endpoint using a tool such as cURL or Postman. For example, you can use cURL like this:

curl -X POST -H "Content-Type: application/json" -d '{"name":"Polynique","age":30}' http://127.0.0.1:8080/

You should see the JSON data you sent in the request returned in the response.

Additional considerations

That’s the basic structure of a REST API built with Rust and Actix. From here, you can expand and customize your API by adding more routes, handling different HTTP methods, and implementing additional functionality as needed.

One thing to keep in mind is that Rust and Node.js have some differences in syntax and conventions, so you may need to make some adjustments as you convert your code from Node.js to Rust. For example, Rust uses snake case for naming variables and functions, while Node.js typically uses camel case. Additionally, Rust has a strong emphasis on type safety, so you’ll need to make sure to properly annotate your types and handle any type-related errors that may arise.

Overall, converting a REST API from Node.js and Express to Rust can be a rewarding process. With a bit of effort and some careful attention to detail, you can build a reliable, high-performance API in Rust!

If you like our post, please share it:

JavaScript Rust