Trait DatabaseBackend

Source

pub trait DatabaseBackend: Send + Sync {
Show 39 methods    // Required methods
    fn backend_type(&self) -> BackendType;
    fn path(&self) -> &Path;
    fn load(&self) -> Result<RequirementsStore>;
    fn save(&self, store: &RequirementsStore) -> Result<()>;

    // Provided methods
    fn update_atomically<F>(&self, update_fn: F) -> Result<RequirementsStore>
       where F: FnOnce(&mut RequirementsStore),
             Self: Sized { ... }
    fn get_requirement(&self, id: &Uuid) -> Result<Option<Requirement>> { ... }
    fn get_requirement_by_spec_id(
        &self,
        spec_id: &str,
    ) -> Result<Option<Requirement>> { ... }
    fn list_requirements(
        &self,
        include_archived: bool,
    ) -> Result<Vec<Requirement>> { ... }
    fn add_requirement(&self, requirement: Requirement) -> Result<Requirement> { ... }
    fn update_requirement(&self, requirement: &Requirement) -> Result<()> { ... }
    fn update_requirement_versioned(
        &self,
        requirement: &Requirement,
    ) -> Result<UpdateResult> { ... }
    fn delete_requirement(&self, id: &Uuid) -> Result<()> { ... }
    fn get_user(&self, id: &Uuid) -> Result<Option<User>> { ... }
    fn get_user_by_handle(&self, handle: &str) -> Result<Option<User>> { ... }
    fn list_users(&self, include_archived: bool) -> Result<Vec<User>> { ... }
    fn add_user(&self, user: User) -> Result<User> { ... }
    fn update_user(&self, user: &User) -> Result<()> { ... }
    fn delete_user(&self, id: &Uuid) -> Result<()> { ... }
    fn get_name(&self) -> Result<String> { ... }
    fn set_name(&self, name: &str) -> Result<()> { ... }
    fn get_title(&self) -> Result<String> { ... }
    fn set_title(&self, title: &str) -> Result<()> { ... }
    fn get_description(&self) -> Result<String> { ... }
    fn set_description(&self, description: &str) -> Result<()> { ... }
    fn create_baseline(
        &self,
        name: String,
        description: Option<String>,
        created_by: String,
    ) -> Result<Baseline> { ... }
    fn list_baselines(&self) -> Result<Vec<Baseline>> { ... }
    fn get_baseline(&self, id: &Uuid) -> Result<Option<Baseline>> { ... }
    fn delete_baseline(&self, id: &Uuid) -> Result<bool> { ... }
    fn compare_with_baseline(
        &self,
        baseline_id: &Uuid,
    ) -> Result<Option<BaselineComparison>> { ... }
    fn compare_baselines(
        &self,
        source_id: &Uuid,
        target_id: &Uuid,
    ) -> Result<Option<BaselineComparison>> { ... }
    fn get_store_version(&self) -> Result<i64> { ... }
    fn exists(&self) -> bool { ... }
    fn create_if_not_exists(&self) -> Result<()> { ... }
    fn queue_list(
        &self,
        _user_id: &str,
        _include_completed: bool,
    ) -> Result<Vec<QueueEntry>> { ... }
    fn queue_add(&self, _entry: QueueEntry) -> Result<()> { ... }
    fn queue_remove(&self, _user_id: &str, _requirement_id: &Uuid) -> Result<()> { ... }
    fn queue_reorder(
        &self,
        _user_id: &str,
        _items: &[(Uuid, i64)],
    ) -> Result<()> { ... }
    fn queue_clear(&self, _user_id: &str, _completed_only: bool) -> Result<()> { ... }
    fn stats(&self) -> Result<DatabaseStats> { ... }
}

Expand description

Core trait for database backends

This trait provides a unified interface for storing and retrieving requirements data, regardless of the underlying storage mechanism.

The design philosophy is:

load() and save() work with the full RequirementsStore for compatibility
Individual CRUD operations are provided for more efficient database access
Backends can choose to implement efficient versions or delegate to load/save

Required Methods§

Source

fn backend_type(&self) -> BackendType

Returns the backend type

Source

fn path(&self) -> &Path

Returns the path to the database file

Source

fn load(&self) -> Result<RequirementsStore>

Loads the entire requirements store from the database

Source

fn save(&self, store: &RequirementsStore) -> Result<()>

Saves the entire requirements store to the database

Provided Methods§

Source

fn update_atomically<F>(&self, update_fn: F) -> Result<RequirementsStore>
where F: FnOnce(&mut RequirementsStore), Self: Sized,

Performs an atomic update operation Default implementation loads, applies changes, and saves

Source

fn get_requirement(&self, id: &Uuid) -> Result<Option<Requirement>>

Gets a requirement by its UUID

Source

fn get_requirement_by_spec_id( &self, spec_id: &str, ) -> Result<Option<Requirement>>

Gets a requirement by its spec_id (e.g., “FR-001”)

Source

fn list_requirements(&self, include_archived: bool) -> Result<Vec<Requirement>>

Lists all requirements (non-archived by default)

Source

fn add_requirement(&self, requirement: Requirement) -> Result<Requirement>

Adds a new requirement Returns the requirement with assigned spec_id Note: This uses the simple SPEC-XXX format for ID generation. For more complex ID generation (with feature/type prefixes), use update_atomically

Source

fn update_requirement(&self, requirement: &Requirement) -> Result<()>

Updates an existing requirement

Source

fn update_requirement_versioned( &self, requirement: &Requirement, ) -> Result<UpdateResult>

Updates a requirement with optimistic locking

This method checks that the requirement’s version matches the database version before updating. If another process modified the requirement, returns a conflict.

The requirement’s version field should contain the version that was loaded. On success, the version is incremented in the database.

Source