mirror of
https://github.com/fawney19/Aether.git
synced 2026-10-11 03:39:49 +08:00
refactor(workspace): enforce layered crate boundaries
This commit is contained in:
elky
@@ -0,0 +1,352 @@
|
||||
use std::collections::BTreeSet;
|
||||
|
||||
use super::{
|
||||
AdminGlobalModelListQuery, AdminProviderModelListQuery, PublicCatalogModelListQuery,
|
||||
PublicCatalogModelSearchQuery, PublicGlobalModelQuery, StoredAdminGlobalModel,
|
||||
StoredAdminGlobalModelPage, StoredAdminProviderModel, StoredProviderActiveGlobalModel,
|
||||
StoredProviderModelStats, StoredPublicCatalogModel, StoredPublicGlobalModel,
|
||||
StoredPublicGlobalModelPage,
|
||||
};
|
||||
|
||||
/// Immutable input for the shared global-model read policy.
|
||||
///
|
||||
/// Database adapters can load one consistent view and apply exactly the same
|
||||
/// filtering, sorting, pagination, and enrichment rules as the memory adapter
|
||||
/// without depending on the `aether-data` facade.
|
||||
#[derive(Debug, Clone, Default)]
|
||||
pub struct GlobalModelSnapshot {
|
||||
public_global_models: Vec<StoredPublicGlobalModel>,
|
||||
admin_global_models: Vec<StoredAdminGlobalModel>,
|
||||
public_catalog_models: Vec<StoredPublicCatalogModel>,
|
||||
admin_provider_models: Vec<StoredAdminProviderModel>,
|
||||
provider_model_stats: Vec<StoredProviderModelStats>,
|
||||
active_global_model_refs: Vec<StoredProviderActiveGlobalModel>,
|
||||
}
|
||||
|
||||
impl GlobalModelSnapshot {
|
||||
pub fn seed<I>(items: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = StoredPublicGlobalModel>,
|
||||
{
|
||||
Self {
|
||||
public_global_models: items.into_iter().collect(),
|
||||
..Self::default()
|
||||
}
|
||||
}
|
||||
|
||||
pub fn with_admin_global_models<I>(mut self, items: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = StoredAdminGlobalModel>,
|
||||
{
|
||||
self.admin_global_models = items.into_iter().collect();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_public_catalog_models<I>(mut self, items: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = StoredPublicCatalogModel>,
|
||||
{
|
||||
self.public_catalog_models = items.into_iter().collect();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_admin_provider_models<I>(mut self, items: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = StoredAdminProviderModel>,
|
||||
{
|
||||
self.admin_provider_models = items.into_iter().collect();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_provider_model_stats<I>(mut self, items: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = StoredProviderModelStats>,
|
||||
{
|
||||
self.provider_model_stats = items.into_iter().collect();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn with_active_global_model_refs<I>(mut self, items: I) -> Self
|
||||
where
|
||||
I: IntoIterator<Item = StoredProviderActiveGlobalModel>,
|
||||
{
|
||||
self.active_global_model_refs = items.into_iter().collect();
|
||||
self
|
||||
}
|
||||
|
||||
pub fn list_public_models(
|
||||
&self,
|
||||
query: &PublicGlobalModelQuery,
|
||||
) -> StoredPublicGlobalModelPage {
|
||||
let search = normalized_optional_search(query.search.as_deref());
|
||||
let mut filtered = self
|
||||
.public_global_models
|
||||
.iter()
|
||||
.filter(|item| match query.is_active {
|
||||
Some(is_active) => item.is_active == is_active,
|
||||
None => item.is_active,
|
||||
})
|
||||
.filter(|item| {
|
||||
let Some(search) = search.as_deref() else {
|
||||
return true;
|
||||
};
|
||||
item.name.to_ascii_lowercase().contains(search)
|
||||
|| item
|
||||
.display_name
|
||||
.as_deref()
|
||||
.is_some_and(|value| value.to_ascii_lowercase().contains(search))
|
||||
})
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
filtered.sort_by(|left, right| left.name.cmp(&right.name));
|
||||
let total = filtered.len();
|
||||
let items = filtered
|
||||
.into_iter()
|
||||
.skip(query.offset)
|
||||
.take(query.limit)
|
||||
.collect();
|
||||
StoredPublicGlobalModelPage { items, total }
|
||||
}
|
||||
|
||||
pub fn get_public_model_by_name(&self, model_name: &str) -> Option<StoredPublicGlobalModel> {
|
||||
self.public_global_models
|
||||
.iter()
|
||||
.find(|item| item.is_active && item.name == model_name)
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub fn list_public_catalog_models(
|
||||
&self,
|
||||
query: &PublicCatalogModelListQuery,
|
||||
) -> Vec<StoredPublicCatalogModel> {
|
||||
let provider_id = normalized_optional_value(query.provider_id.as_deref());
|
||||
let mut filtered = self
|
||||
.public_catalog_models
|
||||
.iter()
|
||||
.filter(|item| item.is_active)
|
||||
.filter(|item| provider_id.is_none_or(|value| item.provider_id == value))
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
sort_public_catalog_models(&mut filtered);
|
||||
filtered
|
||||
.into_iter()
|
||||
.skip(query.offset)
|
||||
.take(query.limit)
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn search_public_catalog_models(
|
||||
&self,
|
||||
query: &PublicCatalogModelSearchQuery,
|
||||
) -> Vec<StoredPublicCatalogModel> {
|
||||
let provider_id = normalized_optional_value(query.provider_id.as_deref());
|
||||
let search = query.search.trim().to_ascii_lowercase();
|
||||
let mut filtered = self
|
||||
.public_catalog_models
|
||||
.iter()
|
||||
.filter(|item| item.is_active)
|
||||
.filter(|item| provider_id.is_none_or(|value| item.provider_id == value))
|
||||
.filter(|item| {
|
||||
item.provider_model_name
|
||||
.to_ascii_lowercase()
|
||||
.contains(&search)
|
||||
|| item.name.to_ascii_lowercase().contains(&search)
|
||||
|| item.display_name.to_ascii_lowercase().contains(&search)
|
||||
})
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
sort_public_catalog_models(&mut filtered);
|
||||
filtered.truncate(query.limit);
|
||||
filtered
|
||||
}
|
||||
|
||||
pub fn list_admin_global_models(
|
||||
&self,
|
||||
query: &AdminGlobalModelListQuery,
|
||||
) -> StoredAdminGlobalModelPage {
|
||||
let search = normalized_optional_search(query.search.as_deref());
|
||||
let mut filtered = self
|
||||
.admin_global_models
|
||||
.iter()
|
||||
.filter(|item| query.is_active.is_none_or(|value| item.is_active == value))
|
||||
.filter(|item| {
|
||||
let Some(search) = search.as_deref() else {
|
||||
return true;
|
||||
};
|
||||
item.name.to_ascii_lowercase().contains(search)
|
||||
|| item.display_name.to_ascii_lowercase().contains(search)
|
||||
})
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
filtered.sort_by(|left, right| left.name.cmp(&right.name));
|
||||
let total = filtered.len();
|
||||
let items = filtered
|
||||
.into_iter()
|
||||
.skip(query.offset)
|
||||
.take(query.limit)
|
||||
.map(|item| self.enrich_admin_global_model(&item))
|
||||
.collect();
|
||||
StoredAdminGlobalModelPage { items, total }
|
||||
}
|
||||
|
||||
pub fn list_admin_provider_models(
|
||||
&self,
|
||||
query: &AdminProviderModelListQuery,
|
||||
) -> Vec<StoredAdminProviderModel> {
|
||||
let mut filtered = self
|
||||
.admin_provider_models
|
||||
.iter()
|
||||
.filter(|item| item.provider_id == query.provider_id)
|
||||
.filter(|item| query.is_active.is_none_or(|value| item.is_active == value))
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
sort_admin_provider_models(&mut filtered);
|
||||
filtered
|
||||
.into_iter()
|
||||
.skip(query.offset)
|
||||
.take(query.limit)
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn get_admin_provider_model(
|
||||
&self,
|
||||
provider_id: &str,
|
||||
model_id: &str,
|
||||
) -> Option<StoredAdminProviderModel> {
|
||||
self.admin_provider_models
|
||||
.iter()
|
||||
.find(|item| item.provider_id == provider_id && item.id == model_id)
|
||||
.cloned()
|
||||
}
|
||||
|
||||
pub fn list_admin_provider_available_source_models(
|
||||
&self,
|
||||
provider_id: &str,
|
||||
) -> Vec<StoredAdminProviderModel> {
|
||||
let mut filtered = self
|
||||
.admin_provider_models
|
||||
.iter()
|
||||
.filter(|item| item.provider_id == provider_id && item.is_active)
|
||||
.filter(|item| {
|
||||
self.admin_global_models
|
||||
.iter()
|
||||
.find(|global| global.id == item.global_model_id)
|
||||
.is_some_and(|global| global.is_active)
|
||||
})
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
filtered.sort_by(|left, right| {
|
||||
left.global_model_name
|
||||
.cmp(&right.global_model_name)
|
||||
.then_with(|| right.created_at_unix_ms.cmp(&left.created_at_unix_ms))
|
||||
.then_with(|| left.id.cmp(&right.id))
|
||||
});
|
||||
filtered
|
||||
}
|
||||
|
||||
pub fn get_admin_global_model_by_id(
|
||||
&self,
|
||||
global_model_id: &str,
|
||||
) -> Option<StoredAdminGlobalModel> {
|
||||
self.admin_global_models
|
||||
.iter()
|
||||
.find(|item| item.id == global_model_id)
|
||||
.map(|item| self.enrich_admin_global_model(item))
|
||||
}
|
||||
|
||||
pub fn get_admin_global_model_by_name(
|
||||
&self,
|
||||
model_name: &str,
|
||||
) -> Option<StoredAdminGlobalModel> {
|
||||
self.admin_global_models
|
||||
.iter()
|
||||
.find(|item| item.name == model_name)
|
||||
.map(|item| self.enrich_admin_global_model(item))
|
||||
}
|
||||
|
||||
pub fn list_admin_provider_models_by_global_model_id(
|
||||
&self,
|
||||
global_model_id: &str,
|
||||
) -> Vec<StoredAdminProviderModel> {
|
||||
let mut filtered = self
|
||||
.admin_provider_models
|
||||
.iter()
|
||||
.filter(|item| item.global_model_id == global_model_id)
|
||||
.cloned()
|
||||
.collect::<Vec<_>>();
|
||||
sort_admin_provider_models(&mut filtered);
|
||||
filtered
|
||||
}
|
||||
|
||||
pub fn list_provider_model_stats(
|
||||
&self,
|
||||
provider_ids: &[String],
|
||||
) -> Vec<StoredProviderModelStats> {
|
||||
let provider_ids = provider_ids.iter().collect::<BTreeSet<_>>();
|
||||
self.provider_model_stats
|
||||
.iter()
|
||||
.filter(|item| provider_ids.contains(&item.provider_id))
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
|
||||
pub fn list_active_global_model_ids_by_provider_ids(
|
||||
&self,
|
||||
provider_ids: &[String],
|
||||
) -> Vec<StoredProviderActiveGlobalModel> {
|
||||
let provider_ids = provider_ids.iter().collect::<BTreeSet<_>>();
|
||||
self.active_global_model_refs
|
||||
.iter()
|
||||
.filter(|item| provider_ids.contains(&item.provider_id))
|
||||
.cloned()
|
||||
.collect()
|
||||
}
|
||||
|
||||
fn enrich_admin_global_model(&self, item: &StoredAdminGlobalModel) -> StoredAdminGlobalModel {
|
||||
let mut enriched = item.clone();
|
||||
let providers = self
|
||||
.admin_provider_models
|
||||
.iter()
|
||||
.filter(|model| model.global_model_id == item.id)
|
||||
.map(|model| model.provider_id.as_str())
|
||||
.collect::<BTreeSet<_>>();
|
||||
let active_providers = self
|
||||
.admin_provider_models
|
||||
.iter()
|
||||
.filter(|model| {
|
||||
model.global_model_id == item.id && model.is_active && model.is_available
|
||||
})
|
||||
.map(|model| model.provider_id.as_str())
|
||||
.collect::<BTreeSet<_>>();
|
||||
enriched.provider_count = providers.len() as u64;
|
||||
enriched.active_provider_count = active_providers.len() as u64;
|
||||
enriched
|
||||
}
|
||||
}
|
||||
|
||||
fn normalized_optional_value(value: Option<&str>) -> Option<&str> {
|
||||
value.map(str::trim).filter(|value| !value.is_empty())
|
||||
}
|
||||
|
||||
fn normalized_optional_search(value: Option<&str>) -> Option<String> {
|
||||
normalized_optional_value(value).map(str::to_ascii_lowercase)
|
||||
}
|
||||
|
||||
fn sort_public_catalog_models(items: &mut [StoredPublicCatalogModel]) {
|
||||
items.sort_by(|left, right| {
|
||||
left.provider_name
|
||||
.cmp(&right.provider_name)
|
||||
.then_with(|| left.name.cmp(&right.name))
|
||||
.then_with(|| left.id.cmp(&right.id))
|
||||
});
|
||||
}
|
||||
|
||||
fn sort_admin_provider_models(items: &mut [StoredAdminProviderModel]) {
|
||||
items.sort_by(|left, right| {
|
||||
right
|
||||
.created_at_unix_ms
|
||||
.unwrap_or_default()
|
||||
.cmp(&left.created_at_unix_ms.unwrap_or_default())
|
||||
.then_with(|| left.id.cmp(&right.id))
|
||||
});
|
||||
}
|
||||
Reference in New Issue
Block a user