Struct AdminDatabase 

pub struct AdminDatabase { /* private fields */ }

Admin database interface

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

Examples

use reinhardt_admin::core::AdminDatabase;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model};
use std::sync::Arc;
use serde::{Serialize, Deserialize};

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

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

// Placeholder User type for example
#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model, Filter, FilterOperator, FilterValue};
use std::sync::Arc;
use serde::{Serialize, Deserialize};

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::<User>("users", filters, 0, 50).await?;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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 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;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model};
use std::sync::Arc;
use serde::{Serialize, Deserialize};

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

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

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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

Create a new item

Examples

use reinhardt_admin::core::AdminDatabase;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model};
use std::sync::Arc;
use std::collections::HashMap;
use serde::{Serialize, Deserialize};

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::<User>("users", data).await?;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model};
use std::sync::Arc;
use std::collections::HashMap;
use serde::{Serialize, Deserialize};

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::<User>("users", "id", "1", data).await?;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model};
use std::sync::Arc;
use serde::{Serialize, Deserialize};

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

db.delete::<User>("users", "id", "1").await?;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model};
use std::sync::Arc;
use serde::{Serialize, Deserialize};

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::<User>("users", "id", ids).await?;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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;
use reinhardt_db::orm::{DatabaseConnection, DatabaseBackend, Model, Filter, FilterOperator, FilterValue};
use std::sync::Arc;
use serde::{Serialize, Deserialize};

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::<User>("users", filters).await?;

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: Option<i64>,
    name: String,
}

reinhardt_test::impl_test_model!(User, i64, "users");

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

This allows AdminDatabase to be injected via the DI container. The implementation resolves Arc<AdminDatabase> from the container and clones the inner value.

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,

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).