Struct InMemoryRepository 

pub struct InMemoryRepository<E>
where
    E: PersistentEntity,
{ /* private fields */ }

Generic in-memory repository

Provides thread-safe storage for any entity implementing PersistentEntity. All data is stored in memory and lost when the application restarts.

Example

use backbone_core::persistence::{InMemoryRepository, PersistentEntity};

#[derive(Clone, Debug, Serialize, Deserialize)]
struct User {
    id: String,
    name: String,
    created_at: Option<DateTime<Utc>>,
    updated_at: Option<DateTime<Utc>>,
    deleted_at: Option<DateTime<Utc>>,
}

impl PersistentEntity for User { /* ... */ }

let repo = InMemoryRepository::<User>::new();

Implementations

impl<E> InMemoryRepository<E>

where E: PersistentEntity,

pub fn new() -> Self

Create a new empty repository

pub fn with_data(entities: Vec<E>) -> Self

Create a repository with initial data

pub fn len(&self) -> usize

Get the number of active entities

pub fn is_empty(&self) -> bool

Check if store is empty

pub fn trash_len(&self) -> usize

Get the number of items in trash

pub fn clear(&self)

Clear all data (both active and trash)

Trait Implementations

impl<E> CrudRepository<E> for InMemoryRepository<E>

where E: PersistentEntity,

fn create<'life0, 'async_trait>( &'life0 self, entity: E, ) -> Pin<Box<dyn Future<Output = Result<E, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Create a new entity

fn find_by_id<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find entity by ID (excluding soft-deleted)

fn find_by_id_including_deleted<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Find entity by ID (including soft-deleted, for trash operations)

fn update<'life0, 'async_trait>( &'life0 self, entity: E, ) -> Pin<Box<dyn Future<Output = Result<E, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update an existing entity

fn soft_delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Soft delete an entity

fn restore<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Restore a soft-deleted entity

fn hard_delete<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Permanently delete an entity

fn list<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List entities with pagination (excluding soft-deleted)

fn list_deleted<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List soft-deleted entities with pagination

fn count<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Count all entities (excluding soft-deleted)

fn count_deleted<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Count soft-deleted entities

fn bulk_create<'life0, 'async_trait>( &'life0 self, entities: Vec<E>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Bulk create entities

fn empty_trash<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<u64, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Permanently delete all soft-deleted entities

fn update_changed<'life0, 'life1, 'async_trait>( &'life0 self, before: &'life1 E, after: E, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Update an entity from before (the row as read) to after, writing only the fields whose value differs between the two. Ok(None) when the row no longer exists or was soft-deleted since it was read — the write must never revive it.

fn list_deleted_filtered<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List soft-deleted entities with pagination, filters and search — the trash twin of list_filtered.

fn list_filtered<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

List entities with pagination and filters (excluding soft-deleted)

fn list_filtered_with_info<'life0, 'async_trait>( &'life0 self, page: u32, limit: u32, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, PaginationInfo), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

list_filtered, carrying the pagination info (cursor positions included) so the HTTP layer can surface keyset paging. Default: the tuple form with the cursor fields absent; the generated Postgres repositories override this with the real keyset walk.

fn table_name(&self) -> Option<&str>

Group and reduce entities under the same filters as list_filtered.

fn aggregate_filtered<'life0, 'life1, 'async_trait>( &'life0 self, spec: &'life1 AggregateSpec, filters: HashMap<String, String>, ) -> Pin<Box<dyn Future<Output = Result<AggregateResult, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn fetch_related_json<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, _table: &'life1 str, _ids: &'life2 [String], ) -> Pin<Box<dyn Future<Output = Vec<Value>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Hydrate ?include= relations: fetch rows from table by id list, as JSON (raw row_to_json). table comes from EntityRepoMeta::relations() (generator-emitted), never client input. Default: no expansion. The Postgres-backed generated repos override this via impl_crud_repository!.

fn reference_visible<'life0, 'life1, 'life2, 'life3, 'async_trait>( &'life0 self, table: &'life1 str, column: &'life2 str, value: &'life3 Value, ) -> Pin<Box<dyn Future<Output = Result<Option<bool>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait, 'life3: 'async_trait,

Whether the row of table whose column holds value is visible to the caller: read on the request’s own connection and scope, so a row row-level security hides counts as absent. table comes from PersistentEntity::references (generator-emitted), never from client input.

fn exists<'life0, 'life1, 'async_trait>( &'life0 self, id: &'life1 str, ) -> Pin<Box<dyn Future<Output = Result<bool, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Check if an entity exists by ID

fn bulk_soft_delete<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<u64, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Soft-delete many entities by id. Returns the number affected.

fn bulk_restore<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Restore many soft-deleted entities by id. Returns the restored entities.

fn bulk_hard_delete<'life0, 'life1, 'async_trait>( &'life0 self, ids: &'life1 [String], ) -> Pin<Box<dyn Future<Output = Result<u64, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Permanently delete many entities by id. Returns the number affected.

fn restore_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Restore every soft-deleted entity. Returns the restored entities.

fn bulk_update<'life0, 'async_trait>( &'life0 self, entities: Vec<E>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update many entities atomically. Returns the updated entities.

fn bulk_update_changed<'life0, 'async_trait>( &'life0 self, pairs: Vec<(E, E)>, ) -> Pin<Box<dyn Future<Output = Result<Vec<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Update many entities from (before, after) pairs, writing for each only the fields that changed — the batch twin of update_changed, and the path the generic bulk PUT and bulk PATCH take. A row missing or deleted since it was read fails the batch, with the error placed on that item.

impl<E> Default for InMemoryRepository<E>

where E: PersistentEntity,

fn default() -> Self

Returns the “default value” for a type.

impl<E> SearchableRepository<E> for InMemoryRepository<E>

where E: PersistentEntity,

fn search<'life0, 'async_trait>( &'life0 self, filters: HashMap<String, String>, page: u32, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Search entities with filters

fn find_by_field<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, field: &'life1 str, value: &'life2 str, ) -> Pin<Box<dyn Future<Output = Result<Option<E>, RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Find by a specific field value

fn find_all_by_field<'life0, 'life1, 'life2, 'async_trait>( &'life0 self, field: &'life1 str, value: &'life2 str, page: u32, limit: u32, ) -> Pin<Box<dyn Future<Output = Result<(Vec<E>, u64), RepositoryError>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Find all by a specific field value