axiomsync 1.0.0

Core data-processing engine for AxiomSync local retrieval runtime.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use std::sync::{Arc, RwLock};

use crate::config::AppConfig;
use crate::error::Result;
use crate::fs::LocalContextFs;
use crate::index::InMemoryIndex;
use crate::om::OmScope;
use crate::state::SqliteStateStore;

mod archive;
mod commit;
mod context;
mod indexing;
mod lifecycle;
mod memory_extractor;
mod meta;
mod om;
mod paths;

#[cfg(test)]
mod tests;

pub(crate) use om::{OmScopeBinding, resolve_om_scope_binding_for_session_with_config};

#[derive(Clone)]
pub struct Session {
    pub session_id: String,
    fs: LocalContextFs,
    state: SqliteStateStore,
    index: Arc<RwLock<InMemoryIndex>>,
    pub(crate) config: Arc<AppConfig>,
    om_scope_binding_override: Option<OmScopeBinding>,
}

impl std::fmt::Debug for Session {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.debug_struct("Session")
            .field("session_id", &self.session_id)
            .finish_non_exhaustive()
    }
}

impl Session {
    #[must_use]
    pub fn new(
        session_id: impl Into<String>,
        fs: LocalContextFs,
        state: SqliteStateStore,
        index: Arc<RwLock<InMemoryIndex>>,
    ) -> Self {
        Self {
            session_id: session_id.into(),
            fs,
            state,
            index,
            config: Arc::new(AppConfig::default()),
            om_scope_binding_override: None,
        }
    }

    #[must_use]
    pub(crate) fn with_config(mut self, config: Arc<AppConfig>) -> Self {
        self.config = config;
        self
    }

    #[must_use]
    pub fn with_om_scope_binding(mut self, scope_binding: OmScopeBinding) -> Self {
        self.om_scope_binding_override = Some(scope_binding);
        self
    }

    pub fn with_om_scope(
        mut self,
        scope: OmScope,
        thread_id: Option<&str>,
        resource_id: Option<&str>,
    ) -> Result<Self> {
        let scope_binding =
            om::resolve_om_scope_binding_explicit(&self.session_id, scope, thread_id, resource_id)?;
        self.om_scope_binding_override = Some(scope_binding);
        Ok(self)
    }
}