use super::token_expiry;
use crate::storage::SessionStorage;
use crate::types::KnowledgeBase;
use serde::{Deserialize, Serialize};
use std::time::SystemTime;
const SESSION_PREFIX: &str = "semiont.session.";
pub const KNOWLEDGE_BASES_KEY: &str = "semiont.knowledgeBases";
pub const ACTIVE_KEY: &str = "semiont.activeKnowledgeBaseId";
pub const OPEN_RESOURCES_BY_KB_KEY: &str = "semiont.openResourcesByKb";
pub const LAST_VIEWED_RESOURCE_BY_KB_KEY: &str = "semiont.lastViewedResourceByKb";
pub fn session_key(kb_id: &str) -> String {
format!("{SESSION_PREFIX}{kb_id}")
}
pub fn kb_of_session_key(key: &str) -> Option<&str> {
key.strip_prefix(SESSION_PREFIX)
}
pub(crate) fn cache_key(key_prefix: &str, name: &str) -> String {
format!("semiont.cache.{key_prefix}.{name}")
}
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct StoredSession {
pub access: String,
pub refresh: String,
pub client_id: String,
pub token_endpoint: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub revocation_endpoint: Option<String>,
}
impl StoredSession {
pub fn read(stored: &str) -> Option<StoredSession> {
serde_json::from_str(stored).ok()
}
pub fn written(&self) -> String {
serde_json::to_string(self).unwrap_or_default()
}
}
pub fn stored_session(storage: &dyn SessionStorage, kb_id: &str) -> Option<StoredSession> {
StoredSession::read(&storage.get(&session_key(kb_id))?)
}
pub fn store_session(
storage: &dyn SessionStorage,
kb_id: &str,
session: &StoredSession,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
storage.set(&session_key(kb_id), &session.written())
}
pub fn clear_stored_session(
storage: &dyn SessionStorage,
kb_id: &str,
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
storage.delete(&session_key(kb_id))
}
pub fn is_token_expired(token: &str, now: SystemTime) -> bool {
token_expiry(token).is_none_or(|expiry| expiry < now)
}
pub fn load_knowledge_bases(storage: &dyn SessionStorage) -> Vec<KnowledgeBase> {
let Some(stored) = storage.get(KNOWLEDGE_BASES_KEY) else {
return Vec::new();
};
let Ok(entries) = serde_json::from_str::<Vec<serde_json::Value>>(&stored) else {
return Vec::new();
};
entries
.into_iter()
.filter_map(|entry| serde_json::from_value(entry).ok())
.collect()
}
pub fn save_knowledge_bases(
storage: &dyn SessionStorage,
knowledge_bases: &[KnowledgeBase],
) -> Result<(), Box<dyn std::error::Error + Send + Sync>> {
let written = serde_json::to_string(knowledge_bases).unwrap_or_default();
storage.set(KNOWLEDGE_BASES_KEY, &written)
}
#[cfg(test)]
mod tests {
use super::*;
use serde_json::Value;
const STORED: &str = include_str!("../../specs/session/stored.json");
#[test]
fn a_kept_query_is_kept_under_the_tables_prefix_its_persistences_key_prefix_and_its_name() {
let table: Value = serde_json::from_str(STORED).expect("the table is JSON");
let prefix = table["cacheKeyPrefix"]["prefix"]
.as_str()
.expect("the table states the prefix of a kept query's key");
assert_eq!(
cache_key("kb-a", "resource"),
format!("{prefix}kb-a.resource")
);
}
}