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 violations_of(err: &Self::Error) -> Option<Vec<Violation>> { ... }
    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 { ... }
    fn preview_bulk_partial_update<'life0, 'async_trait>(
        &'life0 self,
        items: Vec<(String, HashMap<String, Value>)>,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<BulkPreviewRow<Entity, Self::Error>>>, 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 violations_of(err: &Self::Error) -> Option<Vec<Violation>>

The named rules a refused write broke, when the error carries them, so the response can list them beside the sentence. None by default.

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

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

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

23. What bulk_partial_update would do, with nothing written: each row as it is and as it would become, or why the write would refuse it. Ok(None) (the default) means this service has no dry run, and the route says so instead of guessing.

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