Struct Api

pub struct Api { /* private fields */ }

The Api struct is the main entry point for configuring and running the API server.

This struct provides methods to set up TLS, configure routes, manage CORS settings, apply rate limiting, and bind the server to a specific address and port. It is designed to simplify the process of building secure and high-performance APIs using the Actix Web framework.

Features

• TLS Support: Configure paths to certificate and key files for secure HTTPS communication.
• Rate Limiting: Set request limits to prevent abuse.
• CORS Configuration: Customize cross-origin resource sharing settings.
• Custom Routes: Define and configure API routes using the Routes builder.

Example

use rusty_api::Api;

let api = Api::new()
     .certs("certs/cert.pem", "certs/key.pem")
     .rate_limit(5, 10)
     .bind("127.0.0.1", 8443)
     .configure_cors(|| {
         rusty_api::Cors::default()
             .allow_any_origin()
             .allow_any_method()
     });
 
api.start();

Implementations

impl Api

pub fn new() -> Self

Create a new instance of the API server with default settings.

Returns

A new Api instance with default values.

Example

use rusty_api::Api;

let api = Api::new();
assert_eq!(api.get_cert_path(), "certs/cert.pem");
assert_eq!(api.get_key_path(), "certs/key.pem");
assert_eq!(api.get_addr(), "127.0.0.1");
assert_eq!(api.get_port(), 8443);
assert_eq!(api.get_rate_limit(), (3, 20));

pub fn certs(self, cert: &str, key: &str) -> Self

Set the certificate and key paths for TLS.

Arguments

• cert - Path to the certificate file.
• key - Path to the private key file.

Returns

A mutable reference to the Api instance.

Example

use rusty_api::Api;

let api = Api::new().certs("path/to/cert.pem", "path/to/key.pem");
assert_eq!(api.get_cert_path(), "path/to/cert.pem");
assert_eq!(api.get_key_path(), "path/to/key.pem");

pub fn rate_limit(self, per_second: u64, burst_size: u32) -> Self

Set the rate limit for API requests.

Arguments

• per_second - Number of requests allowed per second.
• burst_size - Maximum burst size for requests.

Returns

A mutable reference to the Api instance.

Example

use rusty_api::Api;

let api = Api::new().rate_limit(5, 10);
assert_eq!(api.get_rate_limit_per_second(), 5);
assert_eq!(api.get_rate_limit_burst_size(), 10);

pub fn bind(self, addr: &str, port: u16) -> Self

Set the address and port for the API server.

Arguments

• addr - Address to bind the server to.
• port - Port to bind the server to.

Returns

A mutable reference to the Api instance.

Example

use rusty_api::Api;

let api = Api::new().bind("127.0.0.1", 8443);
assert_eq!(api.get_bind_addr(), "127.0.0.1:8443");

pub fn configure_routes(self, routes: Routes) -> Self

Configure custom routes for the API server.

Arguments

• routes - A Routes instance containing the custom routes.

Returns

A mutable reference to the Api instance.

Example

use rusty_api::Api;
use rusty_api::Routes;
use rusty_api::Method;

async fn example_route(_req: rusty_api::HttpRequest) -> rusty_api::HttpResponse {
  rusty_api::HttpResponse::Ok().body("Example route accessed!")
}

let routes = Routes::new()
   .add_route(Method::GET, "/example", example_route);

let api = Api::new()
   .configure_routes(routes);

assert!(api.get_custom_routes().is_some());

pub fn configure_cors<F>(self, cors_config: F) -> Self

where F: Fn() -> Cors + Send + Sync + 'static,

Configure CORS settings.

Arguments

• cors - A closure that takes a Cors instance and returns a modified Cors instance.

Returns

A mutable reference to the Api instance.

Example

use rusty_api;

let api = rusty_api::Api::new()
    .configure_cors(|| {
        rusty_api::Cors::default()
            .allow_any_origin()
            .allow_any_method()
    });

pub fn enable_user_db(self) -> Self

Enable user database with default login and register routes.

pub fn enable_user_db_with_routes( self, login_route: &str, register_route: &str, ) -> Self

Enable user database with optional custom login and register routes.

pub fn start(self)

Start the API server.

This method initializes the server and begins listening for incoming requests. It will block the current thread until the server is stopped.

Example

use rusty_api::Api;

let api = Api::new().start();

pub fn get_cert_path(&self) -> &str

Get the path to the TLS certificate file.

Returns

A string representing the path to the certificate file.

Example

use rusty_api::Api;

let api = Api::new().certs("path/to/cert.pem", "path/to/key.pem");
assert_eq!(api.get_cert_path(), "path/to/cert.pem");

pub fn get_key_path(&self) -> &str

Get the path to the TLS private key file.

Returns

A string representing the path to the private key file.

Example

use rusty_api::Api;

let api = Api::new().certs("path/to/cert.pem", "path/to/key.pem");
assert_eq!(api.get_key_path(), "path/to/key.pem");

pub fn get_addr(&self) -> &str

Get the address the server is bound to.

Returns

A string representing the address.

Example

use rusty_api::Api;
 
let api = Api::new().bind("123.4.5.6", 7891);
assert_eq!(api.get_addr(), "123.4.5.6");

pub fn get_port(&self) -> u16

Get the port the server is bound to.

Returns

A u16 representing the port.

Example

use rusty_api::Api;
 
let api = Api::new().bind("123.4.5.6", 7891);
assert_eq!(api.get_port(), 7891);

pub fn get_rate_limit(&self) -> (u64, u32)

Get the rate limit configuration.

Returns

A tuple containing the rate limit configuration: (requests_per_second, burst_size).

Example

use rusty_api::Api;

let api = Api::new().rate_limit(5, 10);
assert_eq!(api.get_rate_limit(), (5, 10));

pub fn get_bind_addr(&self) -> String

Get the address and port the server is bound to as a single string.

Returns

A string representing the address and port in the format “address:port”.

Example

use rusty_api::Api;

let api = Api::new().bind("123.4.5.6", 7891);
assert_eq!(api.get_bind_addr(), "123.4.5.6:7891");

pub fn get_rate_limit_per_second(&self) -> u64

Get the rate limit per second.

Returns

A u64 representing the number of requests allowed per second.

Example

use rusty_api::Api;

let api = Api::new().rate_limit(5, 10);
assert_eq!(api.get_rate_limit_per_second(), 5);

pub fn get_rate_limit_burst_size(&self) -> u32

Get the rate limit burst size.

Returns

A u32 representing the maximum burst size for requests.

Example

use rusty_api::Api;

let api = Api::new().rate_limit(5, 10);
assert_eq!(api.get_rate_limit_burst_size(), 10);

pub fn get_custom_routes( &self, ) -> Option<&Arc<dyn Fn(&mut ServiceConfig) + Send + Sync>>

Get the custom CORS configuration.

Returns

A reference to the custom CORS configuration closure.