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
85
86
87
88
89
90
91
92
93
94
95

use crate::config::OmScopeConfig;
use crate::error::{AxiomError, Result};
use crate::om::{OmScope, build_scope_key};

use super::OmScopeBinding;

const DEFAULT_OM_SCOPE: &str = "session";
pub(super) const ENV_OM_SCOPE: &str = "AXIOMSYNC_OM_SCOPE";

pub(super) fn resolve_om_scope_binding_for_session_with_config(
    session_id: &str,
    config: &OmScopeConfig,
) -> Result<OmScopeBinding> {
    resolve_om_scope_binding(
        session_id,
        config.scope.as_deref(),
        config.thread_id.as_deref(),
        config.resource_id.as_deref(),
    )
}

pub(super) fn resolve_om_scope_binding(
    session_id: &str,
    scope_raw: Option<&str>,
    thread_id: Option<&str>,
    resource_id: Option<&str>,
) -> Result<OmScopeBinding> {
    let scope_token = scope_raw
        .map(str::trim)
        .filter(|value| !value.is_empty())
        .unwrap_or(DEFAULT_OM_SCOPE)
        .to_ascii_lowercase();
    let scope = match scope_token.as_str() {
        "session" => OmScope::Session,
        "thread" => OmScope::Thread,
        "resource" => OmScope::Resource,
        other => {
            return Err(AxiomError::Validation(format!(
                "invalid {ENV_OM_SCOPE}: {other} (expected: session|thread|resource)"
            )));
        }
    };

    resolve_om_scope_binding_explicit(session_id, scope, thread_id, resource_id)
}

pub(super) fn resolve_om_scope_binding_explicit(
    session_id: &str,
    scope: OmScope,
    thread_id: Option<&str>,
    resource_id: Option<&str>,
) -> Result<OmScopeBinding> {
    let thread_id = normalize_scope_identifier(thread_id);
    let resource_id = normalize_scope_identifier(resource_id);
    let scope_key = build_scope_key(
        scope,
        Some(session_id),
        thread_id.as_deref(),
        resource_id.as_deref(),
    )
    .map_err(|err| AxiomError::Validation(err.to_string()))?;

    let (resolved_session_id, resolved_thread_id, resolved_resource_id) = match scope {
        OmScope::Session => (Some(session_id.to_string()), None, None),
        OmScope::Thread => (None, thread_id, resource_id),
        OmScope::Resource => (None, None, resource_id),
    };
    Ok(OmScopeBinding {
        scope,
        scope_key,
        session_id: resolved_session_id,
        thread_id: resolved_thread_id,
        resource_id: resolved_resource_id,
    })
}

#[cfg(test)]
pub(super) fn parse_env_enabled_default_true(raw: Option<&str>) -> bool {
    let Some(raw) = raw.map(str::trim) else {
        return true;
    };
    if raw.is_empty() {
        return true;
    }
    !matches!(
        raw.to_ascii_lowercase().as_str(),
        "0" | "false" | "no" | "off" | "disabled"
    )
}

fn normalize_scope_identifier(raw: Option<&str>) -> Option<String> {
    raw.map(str::trim)
        .filter(|value| !value.is_empty())
        .map(ToString::to_string)
}