Struct GenericCrudRepository 

pub struct GenericCrudRepository<T, D = SoftDelete>
where
    T: for<'r> FromRow<'r, PgRow> + Send + Unpin,
{ /* private fields */ }

Generic PostgreSQL CRUD repository parameterised by entity type T and delete strategy D (SoftDelete or HardDelete).

All standard CRUD methods are implemented here once. Generated repository structs wrap this type via newtype + Deref and only add entity-specific methods (find_by_*, exists_by_*, partial_update, filtered listings).

Implementations

impl<T, D> GenericCrudRepository<T, D>

where T: for<'r> FromRow<'r, PgRow> + Send + Unpin,

pub fn new(pool: PgPool, table_name: &str) -> Self

pub fn pool(&self) -> &PgPool

pub fn table_name(&self) -> &str

pub async fn create(&self, entity: &T) -> Result<T>

where T: Serialize + Send + Sync,

Insert a new entity row and return the created row.

pub async fn bulk_create(&self, entities: &[T]) -> Result<Vec<T>>

where T: Serialize + Send + Sync,

Insert multiple entity rows inside a single transaction.

pub async fn run_filtered_query( &self, pagination: PaginationParams, base_condition: Option<&str>, filters: &HashMap<String, String>, column_types: &HashMap<String, String>, search_fields: &[&str], ) -> Result<PaginatedResult<T>>

where T: Send + Sync,

Execute a filtered / paginated query against this entity’s table.

base_condition — when Some, it is inserted as the __base_condition filter key which the ORM injects verbatim into the WHERE clause. Use this to add soft-delete guards without touching the caller-supplied filters.

NOTE: prefer the *_scoped entry points for anything a client can reach — they compose the company fence into this condition. This raw form applies no fence and is for internal/job callers that have already established scope.

pub async fn run_aggregate_query( &self, spec: &AggregateSpec, base_condition: Option<&str>, filters: &HashMap<String, String>, column_types: &HashMap<String, String>, search_fields: &[&str], ) -> Result<AggregateResult>

where T: EntityRepoMeta + Send + Sync,

The aggregate twin of Self::run_filtered_query.

Takes the same base_condition so an aggregate is computed over exactly the row set the matching list would return — a total that counted soft-deleted rows, or another tenant’s, would be wrong in a way no caller could see.

impl<T> GenericCrudRepository<T, SoftDelete>

where T: for<'r> FromRow<'r, PgRow> + Send + Unpin,

pub async fn find_by_text_field( &self, field: &str, value: &str, ) -> Result<Option<T>>

Find an active entity by a unique text field.

Filters metadata->>'deleted_at' IS NULL automatically.

pub async fn exists_by_text_field( &self, field: &str, value: &str, ) -> Result<bool>

Check existence by a unique text field (active records only).

pub async fn find_by_uuid_field( &self, field: &str, value: Uuid, ) -> Result<Option<T>>

Find an active entity by a unique UUID field.

pub async fn exists_by_uuid_field( &self, field: &str, value: Uuid, ) -> Result<bool>

Check existence by a unique UUID field (active records only).

pub async fn list_paginated_filtered( &self, pagination: PaginationParams, filters: Option<&HashMap<String, String>>, ) -> Result<PaginatedResult<T>>

where T: EntityRepoMeta + Send + Sync,

Paginate active entities with filter and search support.

Requires T: EntityRepoMeta for column type hints and search fields.

pub async fn aggregate_filtered( &self, spec: &AggregateSpec, filters: Option<&HashMap<String, String>>, ) -> Result<AggregateResult>

where T: EntityRepoMeta + Send + Sync,

Group and reduce active entities, skipping the soft-deleted.

pub async fn list_paginated_filtered_scoped( &self, pagination: PaginationParams, filters: Option<&HashMap<String, String>>, company: Option<Uuid>, ) -> Result<PaginatedResult<T>>

where T: EntityRepoMeta + Send + Sync,

Paginate active entities, fenced to company.

The company-scoped counterpart of Self::list_paginated_filtered and the one any client-reachable read should use. Fails closed: a fenced entity with no company returns MissingCompanyScope rather than every company’s rows.

The fence is ANDed into the same __base_condition the soft-delete guard uses, so it lands in SQL — which is what keeps total honest. A post-filter in the handler would fetch limit rows and return the survivors, leaving callers unable to tell “end of data” from “filtered”, and could not fix COUNT at all.

pub async fn list_deleted_filtered_scoped( &self, pagination: PaginationParams, filters: Option<&HashMap<String, String>>, company: Option<Uuid>, ) -> Result<PaginatedResult<T>>

where T: EntityRepoMeta + Send + Sync,

Paginate soft-deleted entities, fenced to company.

/trash is the worse leak of the two: it serves rows whose owners were told the data is gone. Same fence, same fail-closed contract.

pub async fn list_deleted_filtered( &self, pagination: PaginationParams, filters: Option<&HashMap<String, String>>, ) -> Result<PaginatedResult<T>>

where T: EntityRepoMeta + Send + Sync,

Paginate soft-deleted entities with filter support.

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

Find an active (non-deleted) entity by primary key.

pub async fn find_all(&self) -> Result<Vec<T>>

Return all active (non-deleted) entities.

pub async fn update(&self, id: &str, entity: &T) -> Result<Option<T>>

where T: Serialize + Send + Sync,

Full update — skips silently if the record is already soft-deleted.

pub async fn delete(&self, id: &str) -> Result<bool>

Soft-delete an entity (sets metadata.deleted_at).

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

Count active (non-deleted) entities.

pub async fn exists(&self, id: &str) -> Result<bool>

Return true if an active entity with the given ID exists.

pub async fn list_paginated( &self, pagination: PaginationParams, ) -> Result<PaginatedResult<T>>

Paginate active entities (most-recent-first by ID).

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

Set metadata.deleted_at to NOW() (soft delete).

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

Remove deleted_at from metadata, restoring the entity.

pub async fn list_deleted( &self, pagination: PaginationParams, ) -> Result<PaginatedResult<T>>

Paginate soft-deleted entities (trash view).

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

Permanently delete all soft-deleted rows (empty trash).

pub async fn find_deleted_by_id(&self, id: &str) -> Result<Option<T>>

Find a soft-deleted entity by primary key.

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

Permanently delete a soft-deleted entity by primary key.

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

Count active (non-deleted) entities.

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

Count soft-deleted entities.

pub async fn bulk_soft_delete(&self, ids: &[String]) -> Result<u64>

Soft-delete many active rows atomically.

pub async fn bulk_restore(&self, ids: &[String]) -> Result<Vec<T>>

Restore many soft-deleted rows atomically, returning the restored rows.

pub async fn bulk_permanent_delete(&self, ids: &[String]) -> Result<u64>

Permanently delete many soft-deleted rows atomically.

pub async fn restore_all(&self) -> Result<Vec<T>>

Restore every soft-deleted row, returning the restored rows. A single UPDATE ... RETURNING is atomic, and the returned rows let the service layer emit a Restored event per entity.

pub async fn bulk_update(&self, entities: &[T]) -> Result<Vec<T>>

where T: Serialize + Send + Sync,

Update many active rows atomically. Every entity must reference an existing active (non-soft-deleted) row or the whole batch is rolled back.

impl<T> GenericCrudRepository<T, HardDelete>

where T: for<'r> FromRow<'r, PgRow> + Send + Sync + Unpin + Serialize,

pub async fn find_by_text_field( &self, field: &str, value: &str, ) -> Result<Option<T>>

Find an entity by a unique text field (no soft-delete guard).

pub async fn exists_by_text_field( &self, field: &str, value: &str, ) -> Result<bool>

Check existence by a unique text field.

pub async fn find_by_uuid_field( &self, field: &str, value: Uuid, ) -> Result<Option<T>>

Find an entity by a unique UUID field.

pub async fn exists_by_uuid_field( &self, field: &str, value: Uuid, ) -> Result<bool>

Check existence by a unique UUID field.

pub async fn list_paginated_filtered( &self, pagination: PaginationParams, filters: Option<&HashMap<String, String>>, ) -> Result<PaginatedResult<T>>

where T: EntityRepoMeta + Send + Sync,

Paginate entities with filter and search support.

pub async fn aggregate_filtered( &self, spec: &AggregateSpec, filters: Option<&HashMap<String, String>>, ) -> Result<AggregateResult>

where T: EntityRepoMeta + Send + Sync,

Group and reduce entities. This mode has no trash to exclude.

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

Find an entity by primary key.

pub async fn find_all(&self) -> Result<Vec<T>>

Return all entities.

pub async fn update(&self, id: &str, entity: &T) -> Result<Option<T>>

Full update.

pub async fn delete(&self, id: &str) -> Result<bool>

Permanently delete an entity by primary key.

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

Count all entities.

pub async fn exists(&self, id: &str) -> Result<bool>

Return true if an entity with the given ID exists.

pub async fn list_paginated( &self, pagination: PaginationParams, ) -> Result<PaginatedResult<T>>

Paginate entities (most-recent-first by ID).

pub async fn bulk_delete(&self, ids: &[String]) -> Result<u64>

Hard-delete many rows atomically. Rolls back unless every id matched.

pub async fn bulk_update(&self, entities: &[T]) -> Result<Vec<T>>

Update many rows atomically. No soft-delete guard in this mode.