Struct GenericCrudService 

pub struct GenericCrudService<E, C, U, R>
where
    E: PersistentEntity + Clone,
    R: CrudRepository<E>,
{ /* private fields */ }

A fully generic CRUD service.

Type parameters:

• E — entity type (must implement PersistentEntity)
• C — create DTO (entity implements FromCreateDto<C>)
• U — update DTO (entity implements ApplyUpdateDto<U>)
• R — repository (implements CrudRepository<E>)

The service always holds an Arc<dyn CrudEventPublisher<E>>. When no publisher is needed, NoOpCrudEventPublisher is used (zero overhead). Event-publish errors are fire-and-forget — they never fail the operation.

Implementations

impl<E, C, U, R> GenericCrudService<E, C, U, R>

where E: PersistentEntity + Clone + FromCreateDto<C> + ApplyUpdateDto<U>, C: Send + Sync + 'static, U: Send + Sync + 'static, R: CrudRepository<E>,

pub fn new( repository: Arc<R>, lifecycle: Arc<dyn ServiceLifecycle<E>>, event_publisher: Arc<dyn CrudEventPublisher<E>>, ) -> Self

Full constructor — supply all three dependencies.

pub fn with_lifecycle( repository: Arc<R>, lifecycle: Arc<dyn ServiceLifecycle<E>>, ) -> Self

Create with a custom lifecycle and the no-op event publisher.

pub fn with_repository(repository: Arc<R>) -> Self

Create with the no-op lifecycle and no-op event publisher (generated default).

pub fn with_event_publisher( self, publisher: Arc<dyn CrudEventPublisher<E>>, ) -> Self

Replace the event publisher on an existing service (builder pattern).

pub fn repository(&self) -> &R

Access the underlying repository for custom query extensions.

pub async fn list( &self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> ServiceResult<(Vec<E>, u64)>

pub async fn list_with_info( &self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> ServiceResult<(Vec<E>, PaginationInfo)>

list, carrying the pagination info (cursor positions included) so the HTTP layer can surface keyset paging on every generic route.

pub async fn aggregate( &self, spec: &AggregateSpec, filters: HashMap<String, String>, ) -> ServiceResult<AggregateResult>

Group and reduce the rows list would return, under the same filters.

pub async fn create(&self, dto: C) -> ServiceResult<E>

pub async fn get_by_id(&self, id: &str) -> ServiceResult<Option<E>>

pub async fn update(&self, id: &str, dto: U) -> ServiceResult<Option<E>>

pub async fn soft_delete(&self, id: &str) -> ServiceResult<bool>

pub async fn restore(&self, id: &str) -> ServiceResult<Option<E>>

pub async fn hard_delete(&self, id: &str) -> ServiceResult<bool>

pub async fn list_deleted( &self, page: u32, limit: u32, ) -> ServiceResult<(Vec<E>, u64)>

pub async fn empty_trash(&self) -> ServiceResult<u64>

pub async fn count(&self) -> ServiceResult<u64>

pub async fn count_active(&self) -> ServiceResult<u64>

pub async fn find_by_id(&self, id: &str) -> ServiceResult<Option<E>>

Alias for get_by_id — used by generated handlers.

pub async fn permanent_delete(&self, id: &str) -> ServiceResult<bool>

Alias for hard_delete — used by generated handlers.

pub async fn count_deleted(&self) -> ServiceResult<u64>

Count soft-deleted entities.

pub async fn get_deleted_by_id(&self, id: &str) -> ServiceResult<Option<E>>

Retrieve a soft-deleted entity by ID (includes deleted records).

pub async fn list_deleted_filtered( &self, page: u32, limit: u32, _filters: HashMap<String, String>, ) -> ServiceResult<(Vec<E>, u64)>

List deleted entities with filter support (filters currently ignored, delegates to list_deleted).

pub async fn upsert(&self, dto: C) -> ServiceResult<E>

Upsert: create the entity if it doesn’t exist (no ID-based lookup — always creates).

pub async fn partial_update( &self, id: &str, fields: HashMap<String, Value>, ) -> ServiceResult<Option<E>>

where E: Serialize + DeserializeOwned,

Apply a partial update from a JSON map of field values.

Fields not present in the map are left unchanged.

pub async fn bulk_create(&self, dtos: Vec<C>) -> ServiceResult<Vec<E>>

where E: FromCreateDto<C>,

pub async fn bulk_soft_delete(&self, ids: Vec<String>) -> ServiceResult<u64>

Soft-delete many entities by id (atomic).

pub async fn bulk_restore(&self, ids: Vec<String>) -> ServiceResult<Vec<E>>

Restore many soft-deleted entities by id (atomic).

pub async fn restore_all(&self) -> ServiceResult<u64>

Restore every soft-deleted entity (atomic). Returns the number restored. Emits a Restored event per entity, mirroring bulk_restore.

pub async fn bulk_permanent_delete( &self, ids: Vec<String>, ) -> ServiceResult<u64>

Permanently delete many soft-deleted entities by id (atomic).

pub async fn bulk_update( &self, items: Vec<(String, U)>, ) -> ServiceResult<Vec<E>>

Full-update many entities (atomic). Each item is (id, UpdateDto).

pub async fn bulk_partial_update( &self, items: Vec<(String, HashMap<String, Value>)>, ) -> ServiceResult<Vec<E>>

where E: Serialize + DeserializeOwned,

Partial-update many entities (atomic). Each item is (id, field_map).

Trait Implementations

impl<E, C, U, R> Clone for GenericCrudService<E, C, U, R>

where E: PersistentEntity + Clone, R: CrudRepository<E>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E, C, U, R> CrudService<E, C, U> for GenericCrudService<E, C, U, R>

where E: PersistentEntity + Clone + Serialize + DeserializeOwned + FromCreateDto<C> + ApplyUpdateDto<U> + Send + Sync + 'static, C: Send + Sync + 'static, U: Send + Sync + 'static, R: CrudRepository<E> + Send + Sync + 'static,

Blanket impl so that any GenericCrudService<E, C, U, R> automatically satisfies CrudService<E, C, U> without generated adapter structs.

Generated code emits only a type alias: pub type UserService = GenericCrudService<User, CreateUserDto, UpdateUserDto, UserRepository>;

That alias now directly implements CrudService and can be passed to BackboneCrudHandler without any additional boilerplate.

type Error = ServiceError

Error type for service operations

fn entity_name() -> &'static str

Entity name for error messages (e.g., “User”, “Role”)

fn fetch_related_json<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, table: &'life1 str, ids: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Vec<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Hydrate ?include= relations: fetch rows from table by id list, as JSON. Default: no expansion. GenericCrudService delegates to its repository.

fn list<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), ServiceError>> + Send + 'async_trait>>

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

List entities with pagination and filters

fn list_with_info<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, PaginationInfo), ServiceError>> + Send + 'async_trait>>

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

list, carrying the pagination info (cursor positions included) so the HTTP layer can surface keyset paging. Default: the tuple form — generated services override this with the repository’s cursors.

fn aggregate<'life0, 'life1, 'async_trait>( &'life0 self, spec: &'life1 AggregateSpec, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<AggregateResult, ServiceError>> + Send + 'async_trait>>

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

Group and reduce the rows list would return, under the same filters.

fn table_name(&self) -> Option<&str>

The schema-qualified table this service reads, when it has one.

fn create<'life0, 'async_trait>( &'life0 self, dto: C, ) -> Pin<Box<dyn Future<Output = Result<E, ServiceError>> + Send + 'async_trait>>

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

Create a new entity

fn get_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, ServiceError>> + Send + 'async_trait>>

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

Get entity by ID

fn update<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, dto: U, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, ServiceError>> + Send + 'async_trait>>

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

Full update of entity

fn partial_update<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, fields: HashMap<String, Value>, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, ServiceError>> + Send + 'async_trait>>

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

Partial update with specific fields

fn soft_delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, ServiceError>> + Send + 'async_trait>>

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

Soft delete entity

fn bulk_create<'life0, 'async_trait>( &'life0 self, items: Vec<C>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, ServiceError>> + Send + 'async_trait>>

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

Bulk create multiple entities

fn upsert<'life0, 'async_trait>( &'life0 self, dto: C, ) -> Pin<Box<dyn Future<Output = Result<E, ServiceError>> + Send + 'async_trait>>

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

Upsert (create or update)

fn list_deleted<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), ServiceError>> + Send + 'async_trait>>

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

List deleted entities (trash)

fn restore<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, ServiceError>> + Send + 'async_trait>>

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

Restore soft-deleted entity

fn empty_trash<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, ServiceError>> + Send + 'async_trait>>

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

Permanently delete all soft-deleted entities

fn get_deleted_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, ServiceError>> + Send + 'async_trait>>

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

Get deleted entity by ID (from trash)

fn permanent_delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, ServiceError>> + Send + 'async_trait>>

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

Permanently delete a single soft-deleted entity by ID

fn list_deleted_filtered<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), ServiceError>> + Send + 'async_trait>>

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

List deleted entities with filters

fn count_active<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, ServiceError>> + Send + 'async_trait>>

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

Count active (non-deleted) entities

fn count_deleted<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, ServiceError>> + Send + 'async_trait>>

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

Count deleted entities in trash

fn bulk_soft_delete<'life0, 'async_trait>( &'life0 self, ids: Vec<String>, ) -> Pin<Box<dyn Future<Output = Result<u64, ServiceError>> + Send + 'async_trait>>

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

Soft-delete many entities by id. Returns the number affected.

fn bulk_restore<'life0, 'async_trait>( &'life0 self, ids: Vec<String>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, ServiceError>> + Send + 'async_trait>>

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

Restore many soft-deleted entities by id. Returns the restored rows.

fn bulk_permanent_delete<'life0, 'async_trait>( &'life0 self, ids: Vec<String>, ) -> Pin<Box<dyn Future<Output = Result<u64, ServiceError>> + Send + 'async_trait>>

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

Permanently delete many soft-deleted entities by id.

fn restore_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, ServiceError>> + Send + 'async_trait>>

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

Restore every soft-deleted entity. Returns the number restored.

fn bulk_update<'life0, 'async_trait>( &'life0 self, items: Vec<(String, U)>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, ServiceError>> + Send + 'async_trait>>

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

Full-update many entities. Each item is (id, UpdateDto).

fn bulk_partial_update<'life0, 'async_trait>( &'life0 self, items: Vec<(String, HashMap<String, Value>)>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, ServiceError>> + Send + 'async_trait>>

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

Partial-update many entities. Each item is (id, field_map).

fn count_active_filtered<'life0, 'async_trait>( &'life0 self, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>

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

Count active entities MATCHING the caller’s filters.