High-performance Rust library for automatic API generation from database schemas.It empowers you to create a blazingly fast REST API that mirrors your database structure, effortlessly handling tables, views, functions, and procedures with Rust's renowned memory safety and zero-cost abstractions. Focused on speed and resource efficiency, it's the ideal solution for microservices and high-traffic APIs.

The name axion not only hints at its foundation on Axum but also resonates with the Spanish word "acción" (action), reflecting its core promise: to take decisive action in transforming your database schema into a fully functional API with minimal effort.

Note: This library is part of a broader ecosystem aimed at simplifying database-to-client workflows, which also includes Python (prism-py) and TypeScript (prism-ts) variants. Axion represents the high-performance Rust engine within this ecosystem.

Note: This is an early version of the library. While functional, it may not be fully stable. Please report any issues you encounter.

Key Features

🚀 High Performance: Built on Tokio and Hyper for maximum throughput.
🔒 Memory Safety: Rust's ownership model guarantees thread safety.
⚡ Async Everything: Fully asynchronous I/O operations without blocking.
🔄 Automatic Route Generation: Create CRUD endpoints for database objects.
🌐 Database Independence: Support for PostgreSQL, MySQL, and SQLite.
🧩 Schema-Based Organization: Routes organized by database schemas for clean API structure.
📊 Enhanced Filtering: Sorting, pagination, and complex query support.
🔍 Metadata API: Explore your database structure programmatically.
🏥 Health Monitoring: Built-in health check endpoints.
📦 Zero Boilerplate: Generate complete APIs with minimal code – true "acción"!
📉 Low Resource Usage: Minimal memory footprint and CPU utilization.

Installation

Add to your Cargo.toml

cargo add axion

Quick Start

Here's a minimal example to get you started with axion:

use axion::prelude::*;

#[tokio::main]
async fn main() -> anyhow::Result<()> {
    // Initialize tracing for logs
    tracing_subscriber::fmt::init();

    // Configure database connection
    let db_config = DbConfig::new()
        .database_type(DatabaseType::Postgres) // Example
        .host("localhost")
        .port(5432)
        .database("yourdb")
        .username("username")
        .password("password")
        .build()?;

    // Create database client
    let db_client = Arc::new(DbClient::new(db_config).await?);
    db_client.test_connection().await?;

    // Create model manager with selected schemas
    let model_manager = Arc::new(ModelManager::new(
        db_client.clone(),
        vec!["public".to_string(), "app".to_string()]
    ).await?);

    // Initialize API generator
    let axion_api = AxionApi::new(model_manager.clone());
    
    // Build router with all generated routes
    let app = axion_api.build_router();
    
    // Serve the application
    let addr = std::net::SocketAddr::from(([127, 0, 0, 1], 8000));
    println!("Listening on http://{}", addr);
    
    axum::Server::bind(&addr)
        .serve(app.into_make_service())
        .await?;

    Ok(())
}

Plans for the Future

Full feature parity with prism-py and prism-ts.
Comprehensive support for all database types (PostgreSQL, MySQL, SQLite, etc.).
Support for all query types (CRUD, JOIN, etc.).
Robust authentication mechanisms (JWT, OAuth, etc.).
Flexible authorization models (RBAC, ABAC, etc.).
Advanced error handling strategies (HTTP, custom, etc.).
Versatile logging options (file, console, etc.).
Customizable API routes and endpoints.
Advanced filtering and sorting capabilities.
Custom pagination solutions.
Support for various response formats (e.g., JSON, XML, etc.).
Custom request validation and sanitization.

Performance

axion is engineered for exceptional performance and minimal resource usage:

Aims for significantly faster response times compared to equivalent dynamic language implementations.
Minimal memory footprint with efficient connection pooling.
High concurrency, capable of handling thousands of simultaneous connections.
Low CPU usage, even under heavy load.

License