GitHub - kent8192/reinhardt-web: Django/DRF-inspired full-stack web framework for Rust

🦀 Django's productivity, Rust's performance

A composable, batteries-included web framework for Rust

Build with the integrated experience of Django/DRF,
or compose only the pieces you need.

# Pin the documented Reinhardt release for reproducibility.
# Omit --version to let Cargo choose the latest stable release.
cargo install reinhardt-admin-cli --version "0.2.0-rc.6"

reinhardt-admin startproject my-api && cd my-api
cargo run --bin manage runserver  # Visit http://127.0.0.1:8000

[dependencies]
# Import as 'reinhardt', published as 'reinhardt-web'
# Default enables the "standard" preset (balanced feature set)
reinhardt = { version = "0.2.0-rc.6", package = "reinhardt-web" }

use reinhardt::prelude::*;
use reinhardt::{Request, Response, StatusCode};

[dependencies]
reinhardt = { version = "0.2.0-rc.6", package = "reinhardt-web", default-features = false, features = ["full"] }

[dependencies]
reinhardt = { version = "0.2.0-rc.6", package = "reinhardt-web", default-features = false, features = ["minimal"] }

[dependencies]
# Core components
reinhardt-http = "0.2.0-rc.6"
reinhardt-urls = "0.2.0-rc.6"

# Optional: Database
reinhardt-db = "0.2.0-rc.6"

# Optional: Authentication
reinhardt-auth = "0.2.0-rc.6"

# Optional: REST API features
reinhardt-rest = "0.2.0-rc.6"

# Optional: Admin panel
reinhardt-admin = "0.2.0-rc.6"

# Optional: Advanced features
reinhardt-graphql = "0.2.0-rc.6"
reinhardt-websockets = "0.2.0-rc.6"

cargo install reinhardt-admin-cli --version "0.2.0-rc.6"

# Create a RESTful API project (default)
reinhardt-admin startproject my-api
cd my-api

reinhardt-admin startproject my-api \
  --reinhardt-version "0.2.0-rc.6" \
  --features standard,admin \
  --no-interactive

reinhardt-admin configure --features minimal,db-sqlite --no-interactive

my-api/
├── Cargo.toml
├── src/
│   ├── lib.rs
│   ├── config.rs
│   ├── apps.rs
│   ├── config/
│   │   ├── settings.rs
│   │   ├── settings/
│   │   │   ├── base.rs
│   │   │   ├── local.rs
│   │   │   ├── staging.rs
│   │   │   └── production.rs
│   │   ├── urls.rs
│   │   └── apps.rs
│   └── bin/
│       └── manage.rs
└── README.md

# Create a pages project
reinhardt-admin startproject my-app --template pages
cd my-app

# Install WASM build tools (first time only)
cargo make install-wasm-tools

# Build WASM and start development server
cargo make dev
# Visit http://127.0.0.1:8000/

# Using the manage command
cargo run --bin manage runserver

# Server will start at http://127.0.0.1:8000

cargo run --bin manage -- runserver --with-pages

# Create a RESTful API app (default)
reinhardt-admin startapp users

# Or explicitly specify type
reinhardt-admin startapp users --with-rest

# Create a Pages app (WASM + SSR)
reinhardt-admin startapp dashboard --with-pages

users/
├── lib.rs
├── models.rs
├── models/
├── views.rs
├── views/
├── serializers.rs
├── serializers/
├── admin.rs
├── admin/
├── urls.rs
├── tests.rs
└── tests/

src/
├── apps.rs                       # aggregator: pub mod polls; #[cfg(server)] pub use polls::PollsConfig;
├── apps/
│   ├── polls.rs                  # per-app entry (sibling of polls/)
│   └── polls/
│       ├── admin.rs              # #[cfg(server)] admin registration
│       ├── client.rs             # #[cfg(client)] aggregator: pub mod components; pub mod pages;
│       ├── client/
│       │   ├── components.rs     # per-app UI (placeholder() returning Page)
│       │   └── pages.rs          # per-app pages (placeholder_page wraps with_nav)
│       ├── models.rs             # #[cfg(server)] models
│       ├── models/               # (.gitkeep — user adds submodules here)
│       ├── serializers.rs        # #[cfg(server)] serializers
│       ├── serializers/          # (.gitkeep)
│       ├── server_fn.rs          # bi-target #[server_fn] handlers (placeholder)
│       ├── tests/                # (.gitkeep)
│       ├── urls.rs               # urls aggregator (cfg-gated submodules)
│       ├── urls/
│       │   ├── server_urls.rs    # #[url_patterns(InstalledApp::polls, mode = server)]
│       │   └── client_router.rs  # #[url_patterns(InstalledApp::polls, mode = client)]
│       └── views.rs              # #[cfg(server)] views
├── bin/
│   └── manage.rs                 # native-only management CLI entry
├── client.rs                     # #[cfg(client)] aggregator: pub mod lib; pub mod components;
├── client/
│   ├── components.rs             # cross-app shell: pub mod nav;
│   ├── components/
│   │   └── nav.rs                # with_nav(body: Page) -> Page helper
│   └── lib.rs                    # #[wasm_bindgen(start)] -> ClientLauncher::router_client(...)
├── config.rs                     # cfg-gated config aggregator
├── config/
│   ├── apps.rs                   # installed_apps! { polls: "polls" }
│   ├── settings.rs               # #[cfg(server)] settings
│   ├── urls.rs                   # #[routes(standalone)] entry
│   └── wasm.rs                   # #[cfg(server)] wasm tooling config
├── lib.rs                        # crate root (`pub mod apps;` is un-gated)
├── shared.rs                     # bi-target shared module
└── shared/
    ├── forms.rs                  # shared form definitions
    └── types.rs                  # DTOs exchanged between WASM and server

// users/urls.rs
//
// 1. Module declarations for sub-URL files (optional, for larger apps):
pub mod api;
pub mod views;

// 2. Aggregator — the single entry point mounted from src/config/urls.rs.
use reinhardt::url_patterns;
use reinhardt::ServerRouter;

use crate::config::apps::InstalledApp;

#[url_patterns(InstalledApp::users, mode = server)]
pub fn server_url_patterns() -> ServerRouter {
	ServerRouter::new()
		.endpoint(views::list_users)
		.endpoint(views::get_user)
		.endpoint(views::create_user)
		.mount("/api/v1/", api::routes())
}

// src/config/urls.rs
use reinhardt::prelude::*;
use reinhardt::routes;

#[routes]
pub fn routes() -> ServerRouter {
	ServerRouter::new()
		.mount("/api/", users::urls::url_patterns())
}

[core]
debug = true
secret_key = "your-secret-key-for-development"

[core.databases.default]
engine = "postgresql"
host = "localhost"
port = 5432
name = "mydb"
user = "postgres"
password = "postgres"

[contacts]
admins = []
managers = []

// src/config/settings.rs
use reinhardt::prelude::*;

// `CoreSettings` is registered under the `core` section, so its fields —
// including the `[core.databases.default]` connection that `migrate` /
// `runserver` resolve — live under `[core]` in the TOML above.
// `ContactSettings` is mounted under `[contacts]`; management commands
// require it through the `HasCommonSettings` bound.
#[settings(core: CoreSettings | contacts: ContactSettings)]
pub struct ProjectSettings;

#[settings(core: CoreSettings | contacts: ContactSettings | cache: CacheSettings)]
pub struct ProjectSettings;

// users/models.rs
use reinhardt::prelude::*;
use reinhardt::auth::Argon2Hasher;

#[user(hasher = Argon2Hasher, username_field = "username", full = true)]
#[model(app_label = "users", table_name = "users")]
pub struct User {
	#[field(primary_key = true)]
	pub id: Uuid,

	#[field(max_length = 100)]
	pub username: String,

	#[field(max_length = 255)]
	pub email: String,

	pub password_hash: Option<String>,

	#[field(max_length = 150)]
	pub first_name: String,

	#[field(max_length = 150)]
	pub last_name: String,

	#[field(default = true)]
	pub is_active: bool,

	#[field(default = false)]
	pub is_staff: bool,

	#[field(default = false)]
	pub is_superuser: bool,

	pub last_login: Option<DateTime<Utc>>,

	#[field(auto_now_add = true)]
	pub date_joined: DateTime<Utc>,

	// Add custom fields as needed:
	#[field(max_length = 50, null = true)]
	pub phone_number: Option<String>,
}

// Generated by #[model(...)] for the User struct above:
impl User {
	pub const fn field_id() -> FieldRef<User, Uuid> { FieldRef::new("id") }
	pub const fn field_username() -> FieldRef<User, String> { FieldRef::new("username") }
	pub const fn field_email() -> FieldRef<User, String> { FieldRef::new("email") }
	pub const fn field_is_active() -> FieldRef<User, bool> { FieldRef::new("is_active") }
	pub const fn field_is_staff() -> FieldRef<User, bool> { FieldRef::new("is_staff") }
	pub const fn field_date_joined() -> FieldRef<User, DateTime<Utc>> { FieldRef::new("date_joined") }
	// ... other fields
}

use reinhardt::prelude::*;
use crate::models::User;

// Django-style lookup helpers with type-safe field references
async fn complex_user_query() -> Result<Vec<User>, Box<dyn std::error::Error>> {
	// Database functions with type-safe field references
	let email_lower = Lower::new(User::field_email().into());
	let username_upper = Upper::new(User::field_username().into());

	// Aggregations using field accessors
	let user_count = Aggregate::count(User::field_id().into());
	let latest_joined = Aggregate::max(User::field_date_joined().into());

	// Window functions for ranking
	let rank_by_join_date = Window::new()
		.partition_by(vec![User::field_is_active().into()])
		.order_by(vec![(User::field_date_joined().into(), "DESC")])
		.function(RowNumber::new());

	// Build and execute the query using QuerySet
	let users = User::objects()
		.filter(User::field_is_active().exact(true))
		.filter(User::field_email().icontains("example.com"))
		.filter(User::field_id().is_in([1_i64, 2, 3]))
		.filter(User::field_date_joined().year().gte(2026))
		.annotate("email_lower", email_lower)
		.annotate("username_upper", username_upper)
		.annotate("rank", rank_by_join_date)
		.order_by(vec![("-date_joined",)])
		.all()
		.await?;

	Ok(users)
}

// Transaction support
async fn create_user_with_transaction(
	conn: &DatabaseConnection,
	user_data: CreateUserRequest
) -> Result<User, Box<dyn std::error::Error>> {
	// Transaction with automatic rollback on error
	transaction(conn, |_tx| async move {
		let user = User::create(user_data).await?;
		log_user_creation(&user).await?;
		Ok(user)
	}).await
}

// src/config/apps.rs
use reinhardt::installed_apps;

// The installed_apps! macro generates:
// - An enum InstalledApp with variants for each app
// - Implementation of conversion traits (From, Into, Display)
// - A registry for app configuration and discovery
//
// Note: Unlike Django's INSTALLED_APPS, this macro is for user apps only.
// Built-in framework features (auth, sessions, admin, etc.) are enabled via
// Cargo feature flags, not through installed_apps!.
//
// Example:
// [dependencies]
// reinhardt = { version = "0.1", features = ["auth", "sessions", "admin"] }
//
// This enables:
// - Automatic app discovery for migrations, admin panel, etc.
// - Type-safe app references throughout your code
// - Centralized app configuration
installed_apps! {
	users: "users",
}

pub fn get_installed_apps() -> Vec<String> {
	InstalledApp::all_apps()
}

use std::collections::HashMap;
use async_trait::async_trait;
use reinhardt::auth::{BaseUserManager, Argon2Hasher, PasswordHasher};
use reinhardt::prelude::*;
use serde_json::Value;
use crate::models::User;

pub struct UserManager {
	hasher: Argon2Hasher,
}

impl UserManager {
	pub fn new() -> Self {
		Self { hasher: Argon2Hasher::new() }
	}
}

#[async_trait]
impl BaseUserManager<User> for UserManager {
	async fn create_user(
		&mut self,
		username: &str,
		password: Option<&str>,
		extra: HashMap<String, Value>,
	) -> Result<User, reinhardt::Error> {
		let mut user = User::build()
			.username(username)
			.email("")
			.password_hash(None)
			.first_name("")
			.last_name("")
			.is_active(true)
			.is_staff(false)
			.is_superuser(false)
			.last_login(None)
			.phone_number(None)
			.finish();
		if let Some(pw) = password {
			user.set_password(pw)?;
		}
		// Apply extra fields (email, first_name, …) as needed …
		user.save().await?;
		Ok(user)
	}
}

let mut users = UserManager::new();
let alice = users
	.create_user(
		"alice",
		Some("secure_password"),
		HashMap::from([("email".into(), serde_json::json!("alice@example.com"))]),
	)
	.await?;

use reinhardt::auth::{GroupManager, CreateGroupData, ObjectPermissionManager};

let mut groups = GroupManager::new();
let editors = groups
	.create_group(CreateGroupData { name: "editors".to_string() })
	.await?;

let mut perms = ObjectPermissionManager::new();
perms.grant_permission("alice", "article:123", "edit").await;

// users/views/profile.rs
use reinhardt::{Response, StatusCode, ViewResult, get};
use reinhardt::auth::CurrentUser;
use crate::models::User;

// JwtAuthMiddleware must be registered in urls.rs to populate AuthState in request extensions
#[get("/profile", name = "get_profile")]
pub async fn get_profile(
	#[inject] CurrentUser(user): CurrentUser<User>,
) -> ViewResult<Response> {
	// CurrentUser<U> loads the full user model from the database using the AuthState
	// set by authentication middleware. Returns an injection error if unauthenticated.
	if !user.is_active() {
		return Err("User account is inactive".into());
	}

	let json = serde_json::to_string(&user)?;
	Ok(Response::new(StatusCode::OK).with_body(json))
}

use reinhardt::di::injectable;

// `scope` is passed as a macro argument; accepted values are
// "singleton", "request", or "transient" (one literal, not an alternation).
// When omitted, `#[injectable]` defaults to `request` and
// `#[injectable_factory]` defaults to `singleton`. `Config` is registered
// as a singleton here so it matches the singleton-scoped
// `database_connection` factory below: mixing a longer-lived dependent
// with a shorter-lived dependency is not rejected by the registry, but it
// captures whichever request-scoped instance was live at first resolution
// and reuses it for the singleton's lifetime — almost never what you want.
#[injectable(scope = "singleton")]
#[derive(Clone)]
pub struct Config {
    #[no_inject]
    pub database_url: String,
}

use reinhardt::db::DatabaseConnection;
use reinhardt::di::{Depends, injectable_factory};

#[injectable_factory(scope = "singleton")]
async fn database_connection(
    #[inject] config: Depends<Config>,
) -> DatabaseConnection {
    DatabaseConnection::connect(&config.database_url)
        .await
        .expect("failed to open database connection")
}

use reinhardt::db::DatabaseConnection;
use reinhardt::{get, Response, StatusCode, ViewResult};
use reinhardt::di::{Depends, DependsResult, injectable_factory};

#[derive(Debug)]
struct DatabaseConnectionError;

#[injectable_factory(scope = "singleton")]
async fn database_connection_result(
    #[inject] config: Depends<Config>,
) -> Result<DatabaseConnection, DatabaseConnectionError> {
    DatabaseConnection::connect(&config.database_url)
        .await
        .map_err(|_| DatabaseConnectionError)
}

#[get("/database/health", name = "database_health")]
async fn database_health(
    #[inject] db: DependsResult<DatabaseConnection, DatabaseConnectionError>,
) -> ViewResult<Response> {
    match db.into_inner() {
        Ok(_) => Ok(Response::new(StatusCode::OK)),
        Err(_) => Ok(Response::new(StatusCode::SERVICE_UNAVAILABLE)),
    }
}

use reinhardt::{get, Response, StatusCode, ViewResult};
use reinhardt::di::Depends;
use reinhardt::db::DatabaseConnection;
use reinhardt::extractors::Path;
use crate::models::User;

#[get("/users/{id}/", name = "get_user")]
pub async fn get_user(
    Path(id): Path<i64>,
    #[inject] db: Depends<DatabaseConnection>,
) -> ViewResult<Response> {
    let user = User::objects().filter(User::field_id().eq(id)).get().await?;
    let body = serde_json::to_string(&user)?;
    Ok(Response::new(StatusCode::OK).with_body(body))
}

pub async fn uncached_handler(
    #[inject(cache = false)] db: Depends<DatabaseConnection>,
) -> ViewResult<Response> { /* always a fresh resolution within the scope */ }

use async_trait::async_trait;
use reinhardt::di::{Injectable, InjectionContext, DiResult};

#[async_trait]
impl Injectable for MyService {
    async fn inject(_ctx: &InjectionContext) -> DiResult<Self> {
        Ok(MyService::new())
    }
}

use reinhardt::{get, post, Response, ViewResult};
use serde_json::json;

#[get("/")]
pub async fn hello() -> ViewResult<Response> {
	Ok(Response::ok().with_body("Hello, World!"))
}

#[post("/users")]
pub async fn create_user() -> ViewResult<Response> {
	let body = json!({"status": "created"});
	Response::ok().with_json(&body).map_err(Into::into)
}

use reinhardt::{get, Response, StatusCode, ViewResult};
use reinhardt::extractors::Path;
use reinhardt::di::Depends;
use reinhardt::db::DatabaseConnection;
use crate::models::User;

#[get("/users/{id}/", name = "get_user")]
pub async fn get_user(
	Path(id): Path<i64>,
	#[inject] db: Depends<DatabaseConnection>,
) -> ViewResult<Response> {
	// Path extractor parses and validates the {id} segment automatically
	let user = User::objects()
		.filter(User::field_id().eq(id))
		.get()
		.await?;

	let json = serde_json::to_string(&user)?;
	Ok(Response::new(StatusCode::OK).with_body(json))
}

use reinhardt::ViewResult;  // Pre-defined result type

// users/views/user.rs
use reinhardt::{Response, StatusCode, ViewResult, get};
use reinhardt::extractors::{Path, Query};
use reinhardt::di::Depends;
use reinhardt::db::DatabaseConnection;
use crate::models::User;
use serde::Deserialize;

#[derive(Deserialize)]
pub struct GetUserParams {
	pub include_inactive: Option<bool>,
}

#[get("/users/{id}/", name = "get_user")]
pub async fn get_user(
	Path(id): Path<i64>,
	Query(params): Query<GetUserParams>,
	#[inject] db: Depends<DatabaseConnection>,
) -> ViewResult<Response> {
	let user = User::objects()
		.filter(User::field_id().eq(id))
		.get()
		.await?;

	if !params.include_inactive.unwrap_or(false) && !user.is_active {
		return Err("User is inactive".into());
	}

	let json = serde_json::to_string(&user)?;
	Ok(Response::new(StatusCode::OK).with_body(json))
}

// users/urls.rs
use reinhardt::ServerRouter;

use super::views;

pub fn url_patterns() -> ServerRouter {
	ServerRouter::new()
		.endpoint(views::get_user)  // Path defined in #[get("/users/{id}/")]
}

// users/serializers/user.rs
use serde::{Serialize, Deserialize};
use reinhardt::Validate;

#[derive(Serialize, Deserialize, Validate)]
pub struct CreateUserRequest {
	#[validate(email)]
	pub email: String,
	#[validate(length(min = 3, max = 50))]
	pub username: String,
	#[validate(length(min = 8))]
	pub password: String,
}

#[derive(Serialize, Deserialize)]
pub struct UserResponse {
	pub id: i64,
	pub username: String,
	pub email: String,
	pub is_active: bool,
}

impl From<User> for UserResponse {
	fn from(user: User) -> Self {
		UserResponse {
			id: user.id,
			username: user.username,
			email: user.email,
			is_active: user.is_active,
		}
	}
}

// users/views/user.rs
use reinhardt::{Response, StatusCode, ViewResult, post};
use reinhardt::extractors::Json;
use reinhardt::validation::Validated;
use reinhardt::di::Depends;
use reinhardt::db::DatabaseConnection;
use crate::models::User;
use crate::serializers::{CreateUserRequest, UserResponse};

#[post("/users", name = "create_user")]
pub async fn create_user(
	Json(body): Json<CreateUserRequest>,
	Validated(create_req): Validated<CreateUserRequest>,
	#[inject] db: Depends<DatabaseConnection>,
) -> ViewResult<Response> {
	// Json<T> deserializes the body; Validated<T> runs #[validate] rules and yields the validated value

	// Create user using the auto-generated builder from #[user] + #[model]
	let mut user = User::build()
		.username(create_req.username)
		.email(create_req.email)
		.password_hash(None)
		.first_name("")
		.last_name("")
		.is_active(true)
		.is_staff(false)
		.is_superuser(false)
		.last_login(None)
		.phone_number(None)
		.finish();

	// Hash and set password using BaseUser trait
	user.set_password(&create_req.password)?;

	// Save to database
	user.save(&db).await?;

	let response_data = UserResponse::from(user);
	let json = serde_json::to_string(&response_data)?;

	Ok(Response::new(StatusCode::CREATED).with_body(json))
}