Enum Change 

pub enum Change<M> {
    Create(M),
    Update {
        before: M,
        after: M,
    },
    Delete(Vec<M>),
    Restore(Vec<M>),
    ForceDelete(Vec<M>),
    Action {
        name: &'static str,
        records: Vec<M>,
    },
    HeaderAction {
        name: &'static str,
    },
    Attach {
        owner: M,
        relation: String,
        key: String,
    },
    Detach {
        owner: M,
        relation: String,
        keys: Vec<String>,
    },
}

What one write of a resource changed: the mutation and the rows it wrote.

Resource::before_commit receives it inside the write’s transaction and Resource::after_commit once the transaction commits.

The enum is exhaustive on purpose: an audit hook that matches every variant stops compiling when a new kind of write appears, instead of skipping it.

A create or an update that also links or unlinks records through a many-to-many form field reports the record only: the links are not in M. Read them through the hook’s executor when an audit needs them; the relation table’s own writes report as Change::Attach and Change::Detach.

A save that also writes a Relation::has_one’s child reports the owner here, and the child to the related resource’s hooks, as its own pages would.

Variants

Create(M)

A create wrote this row.

Update

An update wrote after over before, the snapshot the handler loaded and authorized inside the transaction. A submission that names no field writes nothing and still reports an update, with before == after.

Fields

before: M

after: M

Delete(Vec<M>)

A delete or a bulk delete removed these rows, or trashed them on a soft-deleting resource, as they stood before the delete.

Restore(Vec<M>)

A restore brought back these trashed rows, as they stood before it: their deleted-at column still holds the time they were trashed.

ForceDelete(Vec<M>)

A force delete removed these trashed rows for good, as they stood before it.

Action

The custom Action name ran on these rows, as the handler loaded them before it ran.

Fields

name: &'static str

records: Vec<M>

HeaderAction

The HeaderAction name ran, on no record: its audit can record who ran it, through the context, and which action.

Fields

name: &'static str

Attach

A many-to-many relation’s table linked owner to the related record key names.

relation is the owner’s #[has_many(via = ..)] field and key the related resource’s record key, as its URLs spell it whatever spelling the request posted. Attaching a linked record writes nothing and still reports the attach.

Fields

owner: M

relation: String

key: String

Detach

A many-to-many relation’s table unlinked owner from the related records keys name, as their URLs spell them.

Fields

owner: M

relation: String

keys: Vec<String>

Implementations

impl<M> Change<M>

pub fn records(&self) -> &[M]

The rows of this resource the change names: the created row and the updated row as the write left them, the deleted, restored or force-deleted rows and the rows an action ran on as they stood before it, the owner of an attach or a detach, and none for a header action.

pub fn is_action<A, R>(&self) -> bool

where A: Action<R>, R: Resource<Model = M>,

Whether the change is a run of the custom action A.

It compares against A::NAME, as Ability::is_action does, and a type that is not an action of a resource over M does not compile. R is inferred when A is an action of one resource.

fn published(change: &Change<Post>) -> usize {
    if change.is_action::<Publish, _>() {
        change.records().len()
    } else {
        0
    }
}

pub fn is_header_action<A: HeaderAction>(&self) -> bool

Whether the change is a run of the header action A.

It compares against A::NAME, as Ability::is_header_action does.

fn audited(change: &Change<Post>) -> bool {
    !change.is_header_action::<RecountTags>()
}

Trait Implementations

impl<M: Clone> Clone for Change<M>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<M: Debug> Debug for Change<M>

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

Formats the value using the given formatter.

impl<M: Eq> Eq for Change<M>

impl<M: PartialEq> PartialEq for Change<M>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<M: PartialEq> StructuralPartialEq for Change<M>