refactor(workspace): enforce layered crate boundaries

crates/aether-provider/pool/src/plan.rs

@@ -0,0 +1,104 @@
+use aether_data_contracts::repository::provider_catalog::StoredProviderCatalogKey;
+use serde_json::{Map, Value};
+
+pub fn derive_plan_tier(
+    provider_type: &str,
+    key: &StoredProviderCatalogKey,
+    auth_config: Option<&Map<String, Value>>,
+) -> Option<String> {
+    let has_auth_config = auth_config.is_some()
+        || key
+            .encrypted_auth_config
+            .as_deref()
+            .is_some_and(|value| !value.trim().is_empty());
+    if !provider_pool_auth_managed(key, provider_type, has_auth_config) {
+        return None;
+    }
+
+    if let Some(quota_snapshot) = key
+        .status_snapshot
+        .as_ref()
+        .and_then(Value::as_object)
+        .and_then(|snapshot| snapshot.get("quota"))
+        .and_then(Value::as_object)
+    {
+        if let Some(normalized) = derive_plan_tier_from_map(quota_snapshot, provider_type) {
+            return Some(normalized);
+        }
+    }
+
+    if let Some(upstream_metadata) = key.upstream_metadata.as_ref().and_then(Value::as_object) {
+        let provider_bucket = upstream_metadata
+            .get(&provider_type.trim().to_ascii_lowercase())
+            .and_then(Value::as_object);
+        for source in provider_bucket
+            .into_iter()
+            .chain(std::iter::once(upstream_metadata))
+        {
+            if let Some(normalized) = derive_plan_tier_from_map(source, provider_type) {
+                return Some(normalized);
+            }
+        }
+    }
+
+    if let Some(config) = auth_config {
+        if let Some(normalized) = derive_plan_tier_from_map(config, provider_type) {
+            return Some(normalized);
+        }
+    }
+
+    None
+}
+
+fn derive_plan_tier_from_map(source: &Map<String, Value>, provider_type: &str) -> Option<String> {
+    for field in [
+        "plan_type",
+        "tier",
+        "plan",
+        "subscription_title",
+        "subscription_plan",
+    ] {
+        if let Some(value) = source.get(field).and_then(Value::as_str) {
+            if let Some(normalized) = normalize_provider_plan_tier(value, provider_type) {
+                return Some(normalized);
+            }
+        }
+    }
+    None
+}
+
+pub fn derive_oauth_plan_type(
+    provider_type: &str,
+    key: &StoredProviderCatalogKey,
+    auth_config: Option<&Map<String, Value>>,
+) -> Option<String> {
+    derive_plan_tier(provider_type, key, auth_config)
+}
+
+pub fn normalize_provider_plan_tier(value: &str, provider_type: &str) -> Option<String> {
+    let mut normalized = value.trim().to_string();
+    if normalized.is_empty() {
+        return None;
+    }
+
+    let provider_type = provider_type.trim().to_ascii_lowercase();
+    if !provider_type.is_empty() && normalized.to_ascii_lowercase().starts_with(&provider_type) {
+        normalized = normalized[provider_type.len()..]
+            .trim_matches(|ch: char| [' ', ':', '-', '_'].contains(&ch))
+            .to_string();
+    }
+
+    let normalized = normalized.trim().to_ascii_lowercase();
+    (!normalized.is_empty()).then_some(normalized)
+}
+
+fn provider_pool_auth_managed(
+    key: &StoredProviderCatalogKey,
+    provider_type: &str,
+    has_auth_config: bool,
+) -> bool {
+    key.auth_type.trim().eq_ignore_ascii_case("oauth")
+        || (provider_type.trim().eq_ignore_ascii_case("kiro")
+            && key.auth_type.trim().eq_ignore_ascii_case("bearer")
+            && has_auth_config)
+}