Trait CrudService 

pub trait CrudService<Entity, CreateDto, UpdateDto>: Send + Sync
where
    Entity: Send + Sync + 'static,
    CreateDto: Send + Sync + 'static,
    UpdateDto: Send + Sync + 'static,
{
    type Error: Error + Send + Sync;

    // Required methods
    fn entity_name() -> &'static str;
    fn list<'life0, 'async_trait>(
        &'life0 self,
        page: u32,
        limit: u32,
        filters: HashMap<String, String>,
    ) -> Pin<Box<dyn Future<Output = Result<(Vec<Entity>, u64), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn create<'life0, 'async_trait>(
        &'life0 self,
        dto: CreateDto,
    ) -> Pin<Box<dyn Future<Output = Result<Entity, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_by_id<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn update<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
        dto: UpdateDto,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn partial_update<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
        fields: HashMap<String, Value>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn soft_delete<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn bulk_create<'life0, 'async_trait>(
        &'life0 self,
        items: Vec<CreateDto>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn upsert<'life0, 'async_trait>(
        &'life0 self,
        dto: CreateDto,
    ) -> Pin<Box<dyn Future<Output = Result<Entity, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn list_deleted<'life0, 'async_trait>(
        &'life0 self,
        page: u32,
        limit: u32,
    ) -> Pin<Box<dyn Future<Output = Result<(Vec<Entity>, u64), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn restore<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn empty_trash<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn get_deleted_by_id<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn permanent_delete<'life0, 'life1, 'async_trait>(
        &'life0 self,
        id: &'life1 str,
    ) -> Pin<Box<dyn Future<Output = Result<bool, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn list_deleted_filtered<'life0, 'async_trait>(
        &'life0 self,
        page: u32,
        limit: u32,
        filters: HashMap<String, String>,
    ) -> Pin<Box<dyn Future<Output = Result<(Vec<Entity>, u64), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn count_active<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn aggregate<'life0, 'life1, 'async_trait>(
        &'life0 self,
        spec: &'life1 AggregateSpec,
        filters: HashMap<String, String>,
    ) -> Pin<Box<dyn Future<Output = Result<AggregateResult, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn count_deleted<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided methods
    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 { ... }
    fn list_with_info<'life0, 'async_trait>(
        &'life0 self,
        page: u32,
        limit: u32,
        filters: HashMap<String, String>,
    ) -> Pin<Box<dyn Future<Output = Result<(Vec<Entity>, PaginationInfo), Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn table_name(&self) -> Option<&str> { ... }
    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 { ... }
    fn bulk_soft_delete<'life0, 'async_trait>(
        &'life0 self,
        ids: Vec<String>,
    ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bulk_restore<'life0, 'async_trait>(
        &'life0 self,
        ids: Vec<String>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bulk_permanent_delete<'life0, 'async_trait>(
        &'life0 self,
        ids: Vec<String>,
    ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn restore_all<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<u64, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bulk_update<'life0, 'async_trait>(
        &'life0 self,
        items: Vec<(String, UpdateDto)>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
    fn bulk_partial_update<'life0, 'async_trait>(
        &'life0 self,
        items: Vec<(String, HashMap<String, Value>)>,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, Self::Error>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
}

Core trait that application services must implement for generic CRUD operations.

This trait provides the contract for all 11 standard Backbone endpoints. Module-specific services implement this trait with their entity types.

Type Parameters

• Entity: The domain entity type
• CreateDto: DTO for create operations
• UpdateDto: DTO for update operations

Example

#[async_trait]
impl CrudService<User, CreateUserDto, UpdateUserDto> for UserCrudService {
    type Error = ApplicationError;
    fn entity_name() -> &'static str { "User" }
    // ... implement all methods
}

Required Associated Types

type Error: Error + Send + Sync

Error type for service operations

Required Methods

fn entity_name() -> &'static str

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

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

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

1. List entities with pagination and filters

fn create<'life0, 'async_trait>( &'life0 self, dto: CreateDto, ) -> Pin<Box<dyn Future<Output = Result<Entity, Self::Error>> + Send + 'async_trait>>

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

2. Create a new entity

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

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

3. Get entity by ID

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

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

4. 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<Entity>, Self::Error>> + Send + 'async_trait>>

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

5. Partial update with specific fields

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

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

6. Soft delete entity

fn bulk_create<'life0, 'async_trait>( &'life0 self, items: Vec<CreateDto>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, Self::Error>> + Send + 'async_trait>>

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

7. Bulk create multiple entities

fn upsert<'life0, 'async_trait>( &'life0 self, dto: CreateDto, ) -> Pin<Box<dyn Future<Output = Result<Entity, Self::Error>> + Send + 'async_trait>>

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

8. Upsert (create or update)

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

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

9. List deleted entities (trash)

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

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

10. Restore soft-deleted entity

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

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

11. 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<Entity>, Self::Error>> + Send + 'async_trait>>

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

12. 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, Self::Error>> + Send + 'async_trait>>

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

13. 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<Entity>, u64), Self::Error>> + Send + 'async_trait>>

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

14. List deleted entities with filters

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

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

15. Count active (non-deleted) entities

fn aggregate<'life0, 'life1, 'async_trait>( &'life0 self, spec: &'life1 AggregateSpec, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<AggregateResult, Self::Error>> + 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.

The default refuses rather than inventing an answer — see the repository trait for why a zero-filled default would be worse than an error.

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

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

16. Count deleted entities in trash

Provided Methods

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_with_info<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<Entity>, PaginationInfo), Self::Error>> + 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 table_name(&self) -> Option<&str>

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

Used to key a record’s history. Derived from the mount path instead, this would silently return an empty history whenever a route segment and a Postgres schema disagreed — so it is read from the repository, which is the same string the capture trigger writes.

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.

The generated client has always sent filters to /count; the handler never read them, so a filtered count silently answered with the whole table. Nothing caught it because the wrong number is a plausible one.

The default delegates to list, whose total is already built from the same where-clause as its data query — so the filtered count is correct by construction rather than by a second implementation of the same filter parsing, which is exactly how the two drifted apart. It asks for a single row because the rows are discarded; an implementor that can count without fetching may override.

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

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

17. 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<Entity>, Self::Error>> + Send + 'async_trait>>

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

18. 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, Self::Error>> + Send + 'async_trait>>

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

19. Permanently delete many soft-deleted entities by id.

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

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

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

Default is a no-op (0) — only the GenericCrudService blanket impl can perform this without an id list.

fn bulk_update<'life0, 'async_trait>( &'life0 self, items: Vec<(String, UpdateDto)>, ) -> Pin<Box<dyn Future<Output = Result<Vec<Entity>, Self::Error>> + Send + 'async_trait>>

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

21. 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<Entity>, Self::Error>> + Send + 'async_trait>>

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

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

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

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

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

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

type Error = AdapterError

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

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

type Error = AdapterError

impl<R, E> CrudService<E, E, E> for SimpleCrudServiceAdapter<R, E>

where R: CrudRepository<E> + Send + Sync + 'static, E: PersistentEntity + Clone + 'static,

type Error = AdapterError