Follow the principles of REST

Oct 13, 2025 by leolavanderia.com.br 119 views

Overview

In this article, we will explore the process of adding a CRUD (Create, Read, Update, Delete) API to the samples-rust repository using Actix Web and SurrealDB. This feature will provide a sample application that supports multi-model databases, allowing users to test their applications with Keploy.

Why a CRUD API with Actix Web and SurrealDB?

A CRUD API is a fundamental component of any web application, allowing users to interact with data stored in a database. Actix Web is a popular Rust web framework that provides a simple and efficient way to build web applications. SurrealDB, on the other hand, is a multi-model database that supports various data formats, including text and images. By combining Actix Web and SurrealDB, we can create a powerful and flexible API that can handle a wide range of use cases.

Benefits of this Feature

This feature will provide several benefits to users of the samples-rust repository:

Proof of Concept (PoC): This sample app can act as a PoC for users who want to test their applications with a multi-model database.
Improved Testing: By providing instructions for generating test cases using Keploy, users can easily test their applications and ensure that they are working as expected.
Increased Flexibility: The combination of Actix Web and SurrealDB provides a high degree of flexibility, allowing users to store and retrieve various types of data.

Technical Requirements

To implement this feature, we will need to:

Actix Web: We will use Actix Web to build the CRUD API.
SurrealDB: We will use SurrealDB as the multi-model database.
Keploy: We will use Keploy to generate test cases for the API.

Step 1: Setting up the Project

To start, we will need to create a new project using the Actix Web framework. We can do this by running the following command:

cargo new actix-web-surrealdb

This will create a new project with the basic structure for an Actix Web application.

Step 2: Adding SurrealDB to the Project

Next, we will need to add SurrealDB to the project. We can do this by adding the following dependency to our Cargo.toml file:

[dependencies]
actix-web = "4.0.0"
surrealdb = "0.1.0"

We will also need to add the following code to our main.rs file to connect to the SurrealDB instance:

use actix_web::{web, App, HttpServer};
use surrealdb::{Client, Database};

async fn main() -> Result<(), std::io::Error> {
    let client = Client::new("http://localhost:8000").await?;
    let db = client.database("mydb").await?;

    HttpServer::new(move || {
        App::new()
            .service(web::resource("/users").route(web::get().to(get_users)))
            .service(web::resource("/users/{id}").route(web::get().to(get_user)))
            .service(web::resource("/users").route(web::post().to(create_user)))
            .service(web::resource("/users/{id}").route(web::put().to(update_user)))
            .service(web::resource("/users/{id}").route(web::delete().to(delete_user)))
    })
    .bind("127.0.0.1:8080")?
    .run()
    .await
}

This code sets up a new Actix Web server and connects to a SurrealDB instance.

Step 3: Implementing the CRUD API

Next, we will need to implement the CRUD API. We can do this by adding the following code to our main.rs file:

async fn get_users() -> Result<Json<Vec<User>>, Error> {
    let db = db.clone();
    let users = db.query("SELECT * FROM users").await?;
    Ok(Json(users))
}

async fn get_user(id: web::Path<i32>) -> Result<Json<User>, Error> {
    let db = db.clone();
    let user = db.query(format!("SELECT * FROM users WHERE id = {}", id).as_str()).await?;
    Ok(Json(user))
}

async fn create_user(user: web::Json<User>) -> Result<Json<User>, Error> {
    let db = db.clone();
    let user = db.insert("users", user.into_inner()).await?;
    Ok(Json(user))
}

async fn update_user(id: web::Path<i32>, user: web::Json<User>) -> Result<Json<User>, Error> {
    let db = db.clone();
    let user = db.update("users", id, user.into_inner()).await?;
    Ok(Json(user))
}

async fn delete_user(id: web::Path<i32>) -> Result<Json<()>, Error> {
    let db = db.clone();
    db.delete("users", id).await?;
    Ok(Json(()))
}

This code implements the CRUD API using the SurrealDB instance.

Step 4: Generating Test Cases with Keploy

Finally, we will need to generate test cases for the API using Keploy. We can do this by adding the following code to our main.rs file:

#[actix_web::main]
async fn main() -> std::io::Result<()> {
    // ...
    let keploy = Keploy::new("http://localhost:8080");
    keploy.generate_test_cases().await?;
    // ...
}

This code generates test cases for the API using Keploy.

Conclusion

In this article, we have explored the process of adding a CRUD API to the samples-rust repository using Actix Web and SurrealDB. We have implemented the CRUD API and generated test cases for it using Keploy. This feature will provide a sample application that supports multi-model databases, allowing users to test their applications with Keploy.

Future Work

In the future, we can improve this feature by:

Adding more features: We can add more features to the CRUD API, such as support for multiple data formats.
Improving performance: We can improve the performance of the CRUD API by optimizing the database queries.
Adding security: We can add security features to the CRUD API, such as authentication and authorization.

References

Actix Web Documentation
SurrealDB Documentation
Keploy Documentation
Q&A: Adding a CRUD API with Actix Web and SurrealDB =====================================================

Q: What is a CRUD API?

A: A CRUD API (Create, Read, Update, Delete) is a type of API that allows users to interact with data stored in a database. It provides a simple and efficient way to perform basic operations on data, such as creating, reading, updating, and deleting records.

Q: Why use Actix Web and SurrealDB for a CRUD API?

A: Actix Web is a popular Rust web framework that provides a simple and efficient way to build web applications. SurrealDB is a multi-model database that supports various data formats, including text and images. By combining Actix Web and SurrealDB, we can create a powerful and flexible API that can handle a wide range of use cases.

Q: What are the benefits of using SurrealDB?

A: SurrealDB provides several benefits, including:

Multi-model support: SurrealDB supports multiple data formats, including text and images.
High performance: SurrealDB is designed for high-performance applications and can handle large amounts of data.
Flexible schema: SurrealDB allows for flexible schema design, making it easy to adapt to changing data requirements.

Q: How do I implement the CRUD API using Actix Web and SurrealDB?

A: To implement the CRUD API using Actix Web and SurrealDB, you will need to:

Set up the project: Create a new project using the Actix Web framework and add the SurrealDB dependency.
Connect to the database: Connect to the SurrealDB instance using the surrealdb crate.
Implement the CRUD API: Implement the CRUD API using the SurrealDB instance and Actix Web.
Generate test cases: Generate test cases for the API using Keploy.

Q: What are the advantages of using Keploy for generating test cases?

A: Keploy provides several advantages, including:

Easy test case generation: Keploy makes it easy to generate test cases for the API.
High-quality test cases: Keploy generates high-quality test cases that cover a wide range of scenarios.
Improved test coverage: Keploy helps improve test coverage by identifying areas of the API that need more testing.

Q: Can I use Keploy with other frameworks and databases?

A: Yes, Keploy can be used with other frameworks and databases. Keploy is a framework-agnostic and database-agnostic tool that can be used with a wide range of frameworks and databases.

Q: How do I troubleshoot issues with the CRUD API?

A: To troubleshoot issues with the CRUD API, you can:

Check the logs: Check the logs for errors and warnings.
Use a debugger: Use a debugger to step through the code and identify issues.
Test the API: Test the API using a tool like Postman or cURL.

Q: Can I customize the CRUD API to meet my specific needs?

A: Yes, you can customize the CRUD API to meet your specific needs. Actix Web and SurrealDB provide a high degree of flexibility, allowing you to customize the API to meet your specific requirements.

Q: What are the best practices for implementing a CRUD API?

A: The best practices for implementing a CRUD API include:

Follow the principles of REST: Follow the principles of REST (Representational State of Resource) to ensure that the API is easy to use and understand.
Use a consistent naming convention: Use a consistent naming convention to make the API easy to use and understand.
Implement proper error handling: Implement proper error handling to ensure that the API is robust and reliable.

Conclusion

In this Q&A article, we have covered a range of topics related to adding a CRUD API with Actix Web and SurrealDB. We have discussed the benefits of using SurrealDB, how to implement the CRUD API, and how to troubleshoot issues with the API. We have also covered the advantages of using Keploy for generating test cases and how to customize the CRUD API to meet specific needs.