Type Alias KeepsakeRepository 

pub type KeepsakeRepository<C = NoopRelationCache> = PostgresKeepsakeRepository<C>;

Default Postgres-backed keepsake repository.

Aliased Type

pub struct KeepsakeRepository<C = NoopRelationCache> { /* private fields */ }

Implementations

impl<C> KeepsakeRepository<C>

where C: RelationCache,

pub async fn append_audit_event( &self, event: &AuditEvent, ) -> RepositoryResult<i64>

Appends an explicit audit event without mutating lifecycle state.

Prefer apply and revoke for lifecycle mutations so state and audit rows commit together. This helper is for application-owned audit events that do not have a built-in repository command.

impl<C> KeepsakeRepository<C>

where C: RelationCache,

pub async fn due_timed_expiry( &self, now: DateTime<Utc>, limit: i64, ) -> RepositoryResult<Vec<TimedExpiryCandidate>>

Lists due timed expiry candidates in stable batch order.

pub async fn fulfillment_snapshot( &self, keepsake_id: Uuid, ) -> RepositoryResult<FulfillmentSnapshot>

Reads the persisted fulfillment counter snapshot for a keepsake.

Checklist state is not persisted by this adapter yet, so snapshots always contain an empty checklist map.

pub async fn due_fulfilled_expiry( &self, limit: i64, ) -> RepositoryResult<Vec<FulfilledExpiryCandidate>>

Lists fulfillment expiry candidates in stable batch order.

pub async fn expire_due_fulfilled( &self, now: DateTime<Utc>, limit: i64, ) -> RepositoryResult<u64>

Expires a stable batch whose persisted counter snapshots satisfy fulfillment policy.

ChecklistComplete policies cannot be expired via this method because checklist state is not persisted; callers using ChecklistComplete must evaluate fulfillment in application code and call revoke directly.

pub async fn expire_due_timed( &self, now: DateTime<Utc>, limit: i64, ) -> RepositoryResult<u64>

Expires a stable batch of due timed keepsakes.

pub async fn upsert_counter_projection( &self, keepsake_id: Uuid, key: &str, value: i64, observed_at: DateTime<Utc>, ) -> RepositoryResult<()>

Upserts a simple fulfillment counter projection.

impl<C> KeepsakeRepository<C>

where C: RelationCache,

pub async fn apply( &self, command: &ApplyKeepsake, ) -> RepositoryResult<AppliedKeepsake>

Applies a command idempotently and records its audit event atomically.

If an active keepsake already exists for the subject and relation, the existing row is returned with duplicate_prevented set to true, even if the relation has since been disabled. Disabled relations reject new non-duplicate applies.

pub async fn revoke(&self, command: &RevokeKeepsake) -> RepositoryResult<bool>

Revokes an active keepsake from a command and records its audit event atomically.

impl<C> KeepsakeRepository<C>

where C: RelationCache,

pub async fn active_for_subject( &self, subject: &SubjectRef, ) -> RepositoryResult<Vec<Keepsake>>

Returns active keepsakes for a subject.

pub async fn active_relations_for_subject( &self, subject: &SubjectRef, ) -> RepositoryResult<Vec<ActiveRelation>>

Returns active keepsakes for a subject with their relation definitions.

pub async fn active_relations_for_subject_by_ids( &self, subject: &SubjectRef, relation_ids: &[RelationId], ) -> RepositoryResult<Vec<ActiveRelation>>

Returns active keepsakes for a subject, filtered by relation ids.

This is the bounded variant of Self::active_relations_for_subject for request paths that use typed relation specs or another stable relation-id catalogue. Missing ids are ignored, duplicate requested ids do not duplicate output rows, and disabled relation definitions are still returned when their keepsake is active.

pub async fn active_relations_for_subject_by_keys( &self, subject: &SubjectRef, keys: &[RelationKey], ) -> RepositoryResult<Vec<ActiveRelation>>

Returns active keepsakes for a subject, filtered by relation keys.

This is the bounded variant of Self::active_relations_for_subject for request paths that know the small set of relation keys they care about. Missing keys are ignored, and disabled relation definitions are still returned when their keepsake is active.

pub async fn active_membership_scan( &self, relation_id: RelationId, limit: i64, ) -> RepositoryResult<Vec<Keepsake>>

Scans active memberships for a relation in stable order.

pub async fn active_membership_scan_after( &self, relation_id: RelationId, after: Option<&MembershipCursor>, limit: i64, ) -> RepositoryResult<Vec<Keepsake>>

Scans active memberships after a keyset cursor in stable order.

impl<C> KeepsakeRepository<C>

where C: RelationCache,

pub async fn upsert_relation( &self, relation: &RelationDefinition, at: DateTime<Utc>, ) -> RepositoryResult<RelationDefinition>

Inserts or updates a relation definition by its natural relation key.

If a relation already exists for the same kind/name, its stable id is preserved and the returned definition contains the existing id.

pub async fn upsert_relation_spec<Spec>( &self, at: DateTime<Utc>, ) -> RepositoryResult<RelationDefinition>

where Spec: RelationSpec,

Inserts or updates a typed relation spec by its natural relation key.

pub async fn relation_by_id( &self, relation_id: RelationId, ) -> RepositoryResult<Option<RelationDefinition>>

Looks up a relation definition by stable id.

pub async fn relation_by_key( &self, key: &RelationKey, ) -> RepositoryResult<Option<RelationDefinition>>

Looks up a relation definition by its natural relation key.

pub async fn set_relation_enabled( &self, relation_id: RelationId, enabled: bool, at: DateTime<Utc>, ) -> RepositoryResult<bool>

Enables or disables a relation.

Trait Implementations

impl<C> ActiveRelationSource for KeepsakeRepository<C>

where C: RelationCache,

type Error = RepositoryError

Source-specific error type.

async fn active_relations_for_subject<'a>( &'a self, subject: &'a SubjectRef, ) -> RepositoryResult<Vec<ActiveRelation>>

Finds active relation memberships for a subject.

async fn active_relations_for_subject_by_ids<'a>( &'a self, subject: &'a SubjectRef, relation_ids: &'a [RelationId], ) -> RepositoryResult<Vec<ActiveRelation>>

Finds active relation memberships for a subject, filtered by relation ids.

async fn active_relations_for_subject_by_keys<'a>( &'a self, subject: &'a SubjectRef, keys: &'a [RelationKey], ) -> RepositoryResult<Vec<ActiveRelation>>

Finds active relation memberships for a subject, filtered by relation keys.