Struct ModelDelegate 

pub struct ModelDelegate<'a, M: 'static, PK: 'static> { /* private fields */ }

Implementations

impl<'a, M: 'static, PK: 'static> ModelDelegate<'a, M, PK>

pub fn new( runtime: &'a SqlxRuntime, descriptor: &'static ModelDescriptor<M, PK>, ) -> Self

pub fn descriptor(&self) -> &'static ModelDescriptor<M, PK>

pub fn bind(self, ctx: CoolContext) -> ScopedModelDelegate<'a, M, PK>

pub fn find_many(&self) -> FindMany<'a, M, PK>

pub fn find_unique(&self, id: PK) -> FindUnique<'a, M, PK>

pub fn create<I>(&self, input: I) -> CreateRecord<'a, M, PK, I>

pub fn upsert<I>(&self, input: I) -> UpsertRecord<'a, M, PK, I>

Insert-or-update on primary-key conflict. Available only on models whose @id field is client-supplied (no @default(...)); attempting to call this on a model with a server-generated PK is a compile error.

pub fn update(&self, id: PK) -> UpdateRecord<'a, M, PK>

pub fn update_many(&self) -> UpdateMany<'a, M, PK>

Bulk UPDATE by predicate. Refuses to run without at least one filter — table-wide bulk updates are a footgun that should be written in raw SQL.

pub fn delete(&self, id: PK) -> DeleteRecord<'a, M, PK>

pub fn aggregate(&self) -> Aggregate<'a, M, PK>

Side-effect-free aggregate read. Returns a builder that branches into .count() / .sum(col) / .avg(col) / .min(col) / .max(col). Aggregates apply the read policy AND soft-delete column so the result always describes rows the caller could retrieve via find_many.

pub fn delete_many(&self) -> DeleteMany<'a, M, PK>

Bulk DELETE by predicate. Mirrors update_many: applies the delete policy and soft-delete column (if any), fans audit + outbox out per-row via RETURNING, refuses to run without at least one filter.

impl<'a, M: 'static, PK: 'static> ModelDelegate<'a, M, PK>

pub async fn authorize_detail( &self, id: PK, ctx: &CoolContext, ) -> Result<(), CoolError>

where PK: Send + Type<Postgres> + for<'q> Encode<'q, Postgres>,

pub async fn authorize_update( &self, id: PK, ctx: &CoolContext, ) -> Result<(), CoolError>

where PK: Send + Type<Postgres> + for<'q> Encode<'q, Postgres>,

pub async fn authorize_delete( &self, id: PK, ctx: &CoolContext, ) -> Result<(), CoolError>

where PK: Send + Type<Postgres> + for<'q> Encode<'q, Postgres>,

impl<'a, M: 'static, PK: 'static> ModelDelegate<'a, M, PK>

pub fn batch_get(&self, ids: Vec<PK>) -> BatchGet<'a, M, PK>

Fetch many rows by primary key in a single round-trip; missing rows surface as per-item NotFound in the envelope rather than aborting.

pub fn batch_create<I>(&self, inputs: Vec<I>) -> BatchCreate<'a, M, PK, I>

Insert many rows in one outer transaction; each input runs under a nested SAVEPOINT, so a per-item failure (validation, policy, unique conflict) doesn’t take down the rest of the batch.

pub fn batch_update<I>( &self, items: Vec<BatchUpdateItem<PK, I>>, ) -> BatchUpdate<'a, M, PK, I>

Update many rows in one outer transaction with per-item patches and optional if_match versions. Per-item failures roll back at the savepoint; successful items commit together.

pub fn batch_delete(&self, ids: Vec<PK>) -> BatchDelete<'a, M, PK>

Delete many rows by primary key in a single statement; rows that don’t exist (or that policy hid) surface as per-item NotFound.

pub fn batch_upsert<I>(&self, inputs: Vec<I>) -> BatchUpsert<'a, M, PK, I>

Insert-or-update many rows in one outer transaction with per-item savepoints. Eligible only for models whose @id is client-supplied — same compile-time gate as the single-row .upsert(...).

Trait Implementations

impl<'a, M: Clone + 'static, PK: Clone + 'static> Clone for ModelDelegate<'a, M, PK>

fn clone(&self) -> ModelDelegate<'a, M, PK>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a, M: Debug + 'static, PK: Debug + 'static> Debug for ModelDelegate<'a, M, PK>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, M: Copy + 'static, PK: Copy + 'static> Copy for ModelDelegate<'a, M, PK>