Struct AdminDatabase 

pub struct AdminDatabase { /* private fields */ }

Available on server only.

Admin database interface

Provides CRUD operations for admin panel, leveraging reinhardt-orm.

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

// List items with filters
let items = db.list::<AdminRecord>("admin_records", vec![], 0, 50).await?;

Implementations

impl AdminDatabase

pub fn new(connection: DatabaseConnection) -> Self

Create a new admin database interface

This method accepts a DatabaseConnection directly without requiring Arc wrapping. The Arc wrapping is handled internally for you.

pub fn from_arc(connection: Arc<DatabaseConnection>) -> Self

Create a new admin database interface from an Arc-wrapped connection

This is provided for cases where you already have an Arc<DatabaseConnection>. In most cases, you should use new() instead.

pub fn connection(&self) -> &DatabaseConnection

Get a reference to the underlying database connection

pub fn connection_arc(&self) -> Arc<DatabaseConnection>

Get a cloned Arc of the connection (for cases where you need ownership)

In most cases, you should use connection() instead to get a reference.

pub async fn list<M: Model>( &self, table_name: &str, filters: Vec<Filter>, offset: u64, limit: u64, ) -> AdminResult<Vec<HashMap<String, Value>>>

List items with filters, ordering, and pagination

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::{DatabaseConnection, Filter, FilterOperator, FilterValue};

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let filters = vec![
    Filter::new("is_active".to_string(), FilterOperator::Eq, FilterValue::Boolean(true))
];

let items = db.list::<AdminRecord>("admin_records", filters, 0, 50).await?;

pub async fn list_with_condition<M: Model>( &self, table_name: &str, filter_condition: Option<&FilterCondition>, additional_filters: Vec<Filter>, sort_by: Option<&str>, offset: u64, limit: u64, ) -> AdminResult<Vec<HashMap<String, Value>>>

List items with composite filter conditions (supports AND/OR logic)

This method supports complex filter conditions using FilterCondition, which allows building nested AND/OR queries.

Arguments

• table_name - The name of the table to query
• filter_condition - Optional composite filter condition (AND/OR logic)
• additional_filters - Additional simple filters to AND with the condition
• sort_by - Optional sort field (prefix with “-” for descending, e.g., “created_at” or “-created_at”)
• offset - Number of items to skip for pagination
• limit - Maximum number of items to return

pub async fn list_with_condition_and_count<M: Model>( &self, table_name: &str, filter_condition: Option<&FilterCondition>, additional_filters: Vec<Filter>, sort_by: Option<&str>, offset: u64, limit: u64, ) -> AdminResult<(Vec<HashMap<String, Value>>, u64)>

List items and return the filtered total count with one query for non-empty pages.

This uses a windowed COUNT(*) OVER() expression so the admin list endpoint can fetch page rows and pagination metadata without issuing a separate count query on the common path.

pub async fn count_with_condition<M: Model>( &self, table_name: &str, filter_condition: Option<&FilterCondition>, additional_filters: Vec<Filter>, ) -> AdminResult<u64>

Count items with composite filter conditions (supports AND/OR logic)

Arguments

• table_name - The name of the table to query
• filter_condition - Optional composite filter condition (AND/OR logic)
• additional_filters - Additional simple filters to AND with the condition

pub async fn get<M: Model>( &self, table_name: &str, pk_field: &str, id: &str, ) -> AdminResult<Option<HashMap<String, Value>>>

Get a single item by ID

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let item = db.get::<AdminRecord>("admin_records", "id", "1").await?;

pub async fn create<M: Model>( &self, table_name: &str, pk_field: Option<&str>, data: HashMap<String, Value>, ) -> AdminResult<u64>

Create a new item

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::DatabaseConnection;
use std::collections::HashMap;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let mut data = HashMap::new();
data.insert("name".to_string(), serde_json::json!("Alice"));
data.insert("email".to_string(), serde_json::json!("alice@example.com"));

db.create::<AdminRecord>("admin_records", Some("id"), data).await?;

pub async fn update<M: Model>( &self, table_name: &str, pk_field: &str, id: &str, data: HashMap<String, Value>, ) -> AdminResult<u64>

Update an existing item

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::DatabaseConnection;
use std::collections::HashMap;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let mut data = HashMap::new();
data.insert("name".to_string(), serde_json::json!("Alice Updated"));

db.update::<AdminRecord>("admin_records", "id", "1", data).await?;

pub async fn delete<M: Model>( &self, table_name: &str, pk_field: &str, id: &str, ) -> AdminResult<u64>

Delete an item by ID

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

db.delete::<AdminRecord>("admin_records", "id", "1").await?;

pub async fn bulk_delete<M: Model>( &self, table_name: &str, pk_field: &str, ids: Vec<String>, ) -> AdminResult<u64>

Delete multiple items by IDs (bulk delete)

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let ids = vec!["1".to_string(), "2".to_string(), "3".to_string()];
db.bulk_delete::<AdminRecord>("admin_records", "id", ids).await?;

pub async fn bulk_delete_by_table( &self, table_name: &str, pk_field: &str, ids: Vec<String>, ) -> AdminResult<u64>

Delete multiple items by IDs without requiring Model type parameter

This method provides a type-safe way to perform bulk deletions without requiring a Model type parameter. It’s particularly useful for admin actions where the model type may not be known at compile time.

Examples

use reinhardt_admin::core::AdminDatabase;
use reinhardt_db::orm::DatabaseConnection;

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let ids = vec!["1".to_string(), "2".to_string(), "3".to_string()];
db.bulk_delete_by_table("users", "id", ids).await?;

pub async fn count<M: Model>( &self, table_name: &str, filters: Vec<Filter>, ) -> AdminResult<u64>

Count total items with optional filters

Examples

use reinhardt_admin::core::{AdminDatabase, AdminRecord};
use reinhardt_db::orm::{DatabaseConnection, Filter, FilterOperator, FilterValue};

let conn = DatabaseConnection::connect("postgres://localhost/test").await?;
let db = AdminDatabase::new(conn);

let filters = vec![
    Filter::new("is_active".to_string(), FilterOperator::Eq, FilterValue::Boolean(true))
];

let count = db.count::<AdminRecord>("admin_records", filters).await?;

Trait Implementations

impl Clone for AdminDatabase

fn clone(&self) -> AdminDatabase

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Injectable for AdminDatabase

Injectable trait implementation for AdminDatabase

Auto-constructs from DatabaseConnection in the singleton scope when no pre-built AdminDatabase exists. This enables admin DI dependencies to be resolved at request time without requiring async initialization in the synchronous routes() function.

Resolution order:

1. Check singleton cache for pre-built AdminDatabase (backward compat)
2. If not found, construct from DatabaseConnection in singleton scope
3. Cache the constructed instance for subsequent requests

fn inject<'life0, 'async_trait>( ctx: &'life0 InjectionContext, ) -> Pin<Box<dyn Future<Output = DiResult<Self>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Creates an instance of this type by resolving dependencies from the injection context.

fn inject_uncached<'life0, 'async_trait>( ctx: &'life0 InjectionContext, ) -> Pin<Box<dyn Future<Output = Result<Self, DiError>> + Send + 'async_trait>>

where 'life0: 'async_trait, Self: 'async_trait,

Inject without using cache (for cache = false support).