Struct PersistentRepository 

pub struct PersistentRepository<E>
where
    E: EntityTrait,
    E::ModelEx: BaseEntity + Send + Sync,
    <E::ModelEx as BaseEntity>::LoaderType: EntityLoaderTrait<E, ModelEx = E::ModelEx>,
{
    pub db: DatabaseConnection,
    /* private fields */
}

Generic database access for one SeaORM entity.

E is the SeaORM entity; its model must implement BaseEntity. Holds a cloned DatabaseConnection used by every operation.

Fields

db: DatabaseConnection

Connection used by every operation.

Implementations

impl<E> PersistentRepository<E>

where E: EntityTrait, E::ModelEx: BaseEntity + Send + Sync + Clone + Serialize, E::Model: Into<E::ModelEx> + Send + Sync, <E::ModelEx as BaseEntity>::LoaderType: EntityLoaderTrait<E, ModelEx = E::ModelEx>, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

pub fn new(db: DatabaseConnection) -> Self

Creates a repository holding the given connection.

pub fn db(&self) -> &DatabaseConnection

Returns the underlying connection.

pub fn initialize(db: &DatabaseConnection) -> Arc<Self>

Registers a repository for E in the process-wide registry and returns it.

Panics if a repository for E was already initialized.

pub fn find() -> Arc<Self>

Returns the registered repository for E.

Panics if PersistentRepository::initialize was not called first.

pub fn try_find() -> Option<Arc<Self>>

Returns the registered repository for E, or None when uninitialized.

pub fn new_ephemeral(db: DatabaseConnection) -> Self

Creates a repository without touching the shared registry.

pub fn start(&self) -> QueryData<E>

where E::ModelEx: BaseEntity,

Starts a fresh QueryData over E::find().

pub fn start_delete(&self) -> DeleteQueryData<E>

Starts a fresh DeleteQueryData over E::delete_many().

pub fn is_owner<U>(&self, model: &E::ModelEx, user: &U) -> bool

where U: BaseEntity,

Returns true when the model and user share the same id.

pub fn is_owner_auditable<U>(&self, model: &E::ModelEx, user: &U) -> bool

where U: BaseEntity + Clone + Send + Sync, E::ModelEx: BaseAuditableEntity<User = U>,

Returns true when the model’s creator id matches the user id.

pub fn is_accessible<U>(&self, model: &E::ModelEx, user: &U) -> bool

where U: BaseEntity,

Returns true when the user may access the model; currently same as PersistentRepository::is_owner.

pub fn is_accessible_auditable<U>(&self, model: &E::ModelEx, user: &U) -> bool

where U: BaseEntity + Clone + Send + Sync, E::ModelEx: BaseAuditableEntity<User = U>,

Returns true when the user created or last updated the model.

pub async fn transaction<F, T, EType>(&self, f: F) -> Result<T, EType>

where EType: From<DbErr> + Display + Send, F: FnOnce(Arc<DatabaseTransaction>) -> BoxFuture<'static, Result<T, EType>> + Send, T: Send,

Runs the closure inside a transaction, committing on success.

The closure receives an Arc<DatabaseTransaction> so the handle can be freely shared — e.g., moved into RepositoryOptions::with_transaction for nested repository calls. Do not retain clones beyond the closure: committing requires sole ownership of the handle, and a closure error drops it uncommitted, rolling the transaction back.

Returns the closure value or the DbErr from beginning, the closure, or commit.

pub async fn transaction_with_opts<U, F, T, EType>( &self, opts: RepositoryOptions<U>, f: F, ) -> Result<T, EType>

where EType: From<DbErr> + Display + Send, U: BaseEntity + Clone + Send + Sync + 'static, F: FnOnce(Arc<DatabaseTransaction>) -> BoxFuture<'static, Result<T, EType>> + Send, T: Send,

Runs the closure inside opts.txn when one is attached, else in a fresh transaction.

When opts carries a transaction, the closure receives that shared handle directly and no commit/rollback is performed here — the owner of that transaction controls its lifecycle. Otherwise a new transaction is begun from the repository connection and committed on success.

pub async fn get_count<U>( &self, filter: Option<QueryData<E>>, opts: Option<RepositoryOptions<U>>, ) -> Result<u64, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Counts rows matching the filter, applying the cursor when one is set.

U is the RepositoryOptions identity type. The cursor comes from opts when present, else from the QueryData options. Runs against opts.txn when attached, else against the repository connection.

pub async fn get_count_txn( &self, filter: Option<QueryData<E>>, txn: &DatabaseTransaction, ) -> Result<u64, DbErr>

where E::ModelEx: BaseEntity,

Counts rows matching the filter inside the given transaction.

pub async fn count(&self, filter: Option<QueryData<E>>) -> Result<u64, DbErr>

where E::ModelEx: BaseEntity,

Counts rows matching the filter with default options.

pub async fn get_paginated_view<U>( &self, filter: Option<QueryData<E>>, opts: RepositoryOptions<U>, ) -> Result<PageResult<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Returns one cursor page: totals ignore cursor/limit, rows fetch limit + 1 to detect has_next.

U is the RepositoryOptions identity type. The next-page cursor encodes limit and the last row id; it is None when there is no next page. Runs against opts.txn when attached, else against the repository connection.

pub async fn paginated( &self, select: Select<E>, opts: RepositoryOptions<NoUser>, ) -> Result<PageResult<E::ModelEx>, DbErr>

where E::ModelEx: BaseEntity, E::Model: Into<E::ModelEx> + Send + Sync,

Paginates a raw Select: totals ignore cursor/limit and cursors use id > cursor.

Unlike PersistentRepository::get_paginated_view, no recorded ordering direction is consulted because the select carries none. Runs against opts.txn when attached, else against the repository connection.

pub async fn get_all<U>( &self, filter: Option<QueryData<E>>, opts: Option<RepositoryOptions<U>>, ) -> Result<Vec<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Returns all matching rows, applying cursor (opts cursor wins over QueryData cursor) and distinct.

U is the RepositoryOptions identity type. Runs against opts.txn (or the QueryData transaction) when attached, else against the repository connection.

pub async fn get_many<U>( &self, filter: Option<QueryData<E>>, opts: RepositoryOptions<U>, ) -> Result<Vec<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Returns up to opts.limit matching rows, applying cursor and distinct.

U is the RepositoryOptions identity type. The opts cursor is preferred when set, else the QueryData cursor is used. Runs against opts.txn (or the QueryData transaction) when attached.

pub async fn find_many<U>( &self, filter: Option<QueryData<E>>, opts: RepositoryOptions<U>, ) -> Result<Vec<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Alias for PersistentRepository::get_many.

pub async fn find_all( &self, filter: Option<QueryData<E>>, ) -> Result<Vec<E::ModelEx>, DbErr>

where E::ModelEx: BaseEntity,

Returns all matching rows with default options.

pub async fn get_distinct_rows<U>( &self, filter: Option<QueryData<E>>, opts: RepositoryOptions<U>, ) -> Result<Vec<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Returns up to opts.limit distinct rows matching the filter, applying cursor.

U is the RepositoryOptions identity type. Runs against opts.txn (or the QueryData transaction) when attached.

pub async fn get_one<U>( &self, filter: Option<QueryData<E>>, opts: Option<RepositoryOptions<U>>, ) -> Result<Option<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: BaseEntity,

Returns the first matching row, if any, applying cursor when one is set.

U is the RepositoryOptions identity type. Runs against opts.txn (or the QueryData transaction) when attached.

pub async fn find_one( &self, filter: Option<QueryData<E>>, ) -> Result<Option<E::ModelEx>, DbErr>

where E::ModelEx: BaseEntity,

Returns the first matching row with default options.

pub async fn get_by_id(&self, id: i64) -> Result<Option<E::ModelEx>, DbErr>

where E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::ModelEx: BaseEntity, <E::ModelEx as BaseEntity>::LoaderType: EntityLoaderTrait<E, ModelEx = E::ModelEx>,

Finds a row by primary key converted from id; returns None when absent.

pub async fn find_by_id(&self, id: i64) -> Result<Option<E::ModelEx>, DbErr>

where E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::ModelEx: BaseEntity,

Alias for PersistentRepository::get_by_id.

pub async fn get_by_id_with_opts<U>( &self, id: i64, opts: RepositoryOptions<U>, ) -> Result<Option<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::ModelEx: BaseEntity,

Finds a row by id; runs inside opts.txn when one is attached.

U is the RepositoryOptions identity type.

pub async fn create_one<A, U>( &self, active: A, opts: Option<RepositoryOptions<U>>, ) -> Result<E::ModelEx, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::Model: IntoActiveModel<A>, E::ModelEx: BaseEntity, U: BaseEntity + Clone + Send + Sync + 'static, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts one row, filling uid/createdAt/updatedAt (and audit ids when a user id is present).

A is the SeaORM active model for E; U is the RepositoryOptions identity type. Inserts inside opts.txn when attached, else on the repository connection.

pub async fn create_one_simple<A>(&self, active: A) -> Result<E::ModelEx, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::Model: IntoActiveModel<A>, E::ModelEx: BaseEntity, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts one row with default options.

pub async fn create_one_with_opts<A, U>( &self, active: A, opts: RepositoryOptions<U>, ) -> Result<E::ModelEx, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::Model: IntoActiveModel<A>, E::ModelEx: BaseEntity, U: BaseEntity + Clone + Send + Sync + 'static, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts one row with the given options.

A is the SeaORM active model for E; U is the RepositoryOptions identity type.

pub async fn create_many<A, U>( &self, actives: Vec<A>, opts: Option<RepositoryOptions<U>>, ) -> Result<Vec<E::ModelEx>, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::ModelEx: BaseEntity, E::Model: IntoActiveModel<A>, U: BaseEntity + Clone + Send + Sync + 'static, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts each row one at a time, applying base/audit fields to every row.

A is the SeaORM active model for E; U is the RepositoryOptions identity type. Inserts inside opts.txn when attached, else on the repository connection.

pub async fn create_many_simple<A>( &self, actives: Vec<A>, ) -> Result<Vec<E::ModelEx>, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::ModelEx: BaseEntity, E::Model: IntoActiveModel<A>, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts many rows with default options.

pub async fn create_many_with_opts<A, U>( &self, actives: Vec<A>, opts: RepositoryOptions<U>, ) -> Result<Vec<E::ModelEx>, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::ModelEx: BaseEntity, E::Model: IntoActiveModel<A>, U: BaseEntity + Clone + Send + Sync + 'static, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts many rows with the given options.

pub async fn upsert_one<A>(&self, active: A) -> Result<E::ModelEx, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::Model: IntoActiveModel<A> + Clone, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts one row with fresh base fields; does not check for an existing id.

pub async fn upsert_many<A>( &self, actives: Vec<A>, ) -> Result<Vec<E::ModelEx>, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::ModelEx: BaseEntity, E::Model: IntoActiveModel<A> + Clone, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Inserts each row via PersistentRepository::upsert_one, one at a time.

pub async fn upsert_one_with_id<A, F>( &self, active: A, id_fn: F, ) -> Result<E::ModelEx, DbErr>

where A: ActiveModelTrait<Entity = E> + Send + ActiveModelBehavior, E::Model: IntoActiveModel<A> + Clone + BaseEntity, F: Fn(&A) -> Option<i64> + Send, E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Updates the row when id_fn yields an existing id, else inserts it.

Updates refresh updatedAt; inserts fill the full base field set.

pub async fn update_many<F, U>( &self, filter: Option<QueryData<E>>, effector: F, opts: RepositoryOptions<U>, ) -> Result<ChangeResultModel<E::ModelEx>, DbErr>

where F: FnMut(&mut E::Model) -> bool + Send, U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: Into<E::Model> + BaseEntity, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Loads rows via PersistentRepository::get_many, applies effector, and saves changed rows.

The effector mutates each model and returns true to persist it; untouched rows are skipped. Returns the pre-save models that were persisted. U is the RepositoryOptions identity type used for audit fields. Reads and writes run inside opts.txn when attached.

pub async fn find_update_many<F, U>( &self, filter: Option<QueryData<E>>, effector: F, opts: RepositoryOptions<U>, ) -> Result<ChangeResultModel<E::ModelEx>, DbErr>

where F: FnMut(&mut E::Model) -> bool + Send, U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: Into<E::Model> + BaseEntity, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Alias for PersistentRepository::update_many.

pub async fn update_one<F>( &self, filter: Option<QueryData<E>>, effector: F, ) -> Result<Option<E::ModelEx>, DbErr>

where F: FnMut(&mut E::Model) -> bool + Send, E::ModelEx: Into<E::Model> + BaseEntity, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Loads the first matching row, applies effector, and saves it when changed.

Returns None when no row matches; returns the row unchanged when the effector returns false.

pub async fn update_by_id<F>( &self, id: i64, effector: F, ) -> Result<Option<E::ModelEx>, DbErr>

where F: FnMut(&mut E::Model) -> bool + Send, E::ModelEx: Into<E::Model> + BaseEntity, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Loads a row by id, applies effector to the model, and saves it when changed.

Returns None when the id does not exist.

pub async fn update_by_id_with_active<F>( &self, id: i64, effector: F, ) -> Result<Option<E::ModelEx>, DbErr>

where F: FnMut(&mut E::ActiveModel) -> bool + Send, E::ModelEx: Into<E::Model> + BaseEntity, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Loads a row by id, applies effector to the active model, and saves it when changed.

Returns the refetched row unchanged when the effector returns false, or None when the id does not exist.

pub async fn update_one_with_opts<F, U>( &self, filter: Option<QueryData<E>>, effector: F, opts: Option<RepositoryOptions<U>>, ) -> Result<Option<E::ModelEx>, DbErr>

where F: FnMut(&mut E::Model) -> bool + Send, U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: Into<E::Model>, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Loads the first matching row and updates it, recording audit fields from opts when present.

U is the RepositoryOptions identity type. Reads and writes run inside opts.txn (or the filter transaction) when attached.

pub async fn update_by_id_with_opts<F, U>( &self, id: i64, effector: F, opts: Option<RepositoryOptions<U>>, ) -> Result<Option<E::ModelEx>, DbErr>

where F: FnMut(&mut E::Model) -> bool + Send, U: BaseEntity + Clone + Send + Sync + 'static, E::ModelEx: Into<E::Model> + BaseEntity, E::Model: IntoActiveModel<E::ActiveModel> + Clone, E::ActiveModel: ActiveModelTrait<Entity = E> + Send, E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::Column: ColumnTrait + FromStr, <E::Column as FromStr>::Err: Debug,

Loads a row by id and updates it, recording audit fields from opts when present.

U is the RepositoryOptions identity type. Returns None when the id does not exist. Reads and writes run inside opts.txn when attached.

pub async fn delete_many( &self, filter: Option<DeleteQueryData<E>>, ) -> Result<u64, DbErr>

Deletes rows matching the filter and returns the affected row count.

pub async fn delete_many_with_opts<U>( &self, filter: Option<DeleteQueryData<E>>, opts: Option<RepositoryOptions<U>>, ) -> Result<u64, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static,

Deletes rows matching the filter with cursor support and returns the affected row count.

U is the RepositoryOptions identity type. Deletes run inside opts.txn when attached, else on the repository connection.

pub async fn remove_many( &self, filter: Option<DeleteQueryData<E>>, ) -> Result<u64, DbErr>

Alias for PersistentRepository::delete_many.

pub async fn remove_many_with_opts<U>( &self, filter: Option<DeleteQueryData<E>>, opts: Option<RepositoryOptions<U>>, ) -> Result<u64, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static,

Alias for PersistentRepository::delete_many_with_opts.

pub async fn delete_one( &self, filter: Option<DeleteQueryData<E>>, ) -> Result<bool, DbErr>

Deletes matching rows and returns true when at least one row was deleted.

pub async fn delete_one_with_opts<U>( &self, filter: Option<DeleteQueryData<E>>, opts: Option<RepositoryOptions<U>>, ) -> Result<bool, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static,

Deletes matching rows with cursor support; returns true when at least one row was deleted.

U is the RepositoryOptions identity type. Deletes run inside opts.txn when attached.

pub async fn delete_by_id(&self, id: i64) -> Result<Option<E::ModelEx>, DbErr>

where E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::ModelEx: BaseEntity,

Deletes the row with the given id and returns the deleted model, or None when absent.

pub async fn delete_by_id_with_opts<U>( &self, id: i64, opts: Option<RepositoryOptions<U>>, ) -> Result<Option<E::ModelEx>, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static, E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::ModelEx: BaseEntity,

Deletes the row with the given id using opts.txn when attached.

U is the RepositoryOptions identity type. Reads and deletes run inside the attached transaction; otherwise on the repository connection.

pub async fn delete_by_id_txn( &self, id: i64, txn: &DatabaseTransaction, ) -> Result<Option<E::ModelEx>, DbErr>

where E::PrimaryKey: PrimaryKeyTrait, <E::PrimaryKey as PrimaryKeyTrait>::ValueType: From<i64>, E::ModelEx: BaseEntity,

Deletes the row with the given id inside the transaction, returning the deleted model if found.

pub async fn delete_many_txn( &self, filter: Option<DeleteQueryData<E>>, txn: &DatabaseTransaction, ) -> Result<u64, DbErr>

Deletes rows matching the filter inside the transaction, returning the affected row count.

pub async fn delete_many_txn_with_opts<U>( &self, filter: Option<DeleteQueryData<E>>, opts: Option<RepositoryOptions<U>>, txn: &DatabaseTransaction, ) -> Result<u64, DbErr>

where U: BaseEntity + Clone + Send + Sync + 'static,

Deletes rows matching the filter inside the transaction with cursor support.

U is the RepositoryOptions identity type. When opts carries its own transaction it takes precedence; otherwise the explicit txn is used.

Trait Implementations

impl<E> Clone for PersistentRepository<E>

where E: EntityTrait + Clone, E::ModelEx: BaseEntity + Send + Sync, <E::ModelEx as BaseEntity>::LoaderType: EntityLoaderTrait<E, ModelEx = E::ModelEx>,

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.