use std::collections::HashMap;
use std::sync::OnceLock;
use super::{ModelEntry, ModelSchema, TableAccess};
pub(crate) fn table_access(table: &str) -> Option<TableAccess> {
static BY_TABLE: OnceLock<HashMap<String, TableAccess>> = OnceLock::new();
BY_TABLE
.get_or_init(|| {
let mut by_table: HashMap<String, TableAccess> = HashMap::new();
for e in inventory::iter::<ModelEntry> {
let level = by_table
.entry(e.schema.table.to_ascii_lowercase())
.or_insert(TableAccess::Open);
*level = (*level).max(e.schema.table_access());
}
by_table
})
.get(&table.to_ascii_lowercase())
.copied()
}
pub(crate) fn assert_generic(schema: &ModelSchema, who: &str) {
let access =
table_access(schema.table).map_or(schema.table_access(), |r| r.max(schema.table_access()));
assert!(
access == TableAccess::Open,
"{who}: `{}` is admin only (or written by its own flow); a generic view cannot serve it",
schema.table
);
}
pub(crate) fn assert_no_credentials<'a>(
schema: &ModelSchema,
who: &str,
names: impl IntoIterator<Item = &'a str>,
) {
let names: Vec<&str> = names.into_iter().collect();
let found: Vec<&str> = schema
.scalar_fields()
.filter(|f| f.is_credential() && names.iter().any(|n| *n == f.name || *n == f.column))
.map(|f| f.name)
.collect();
assert!(
found.is_empty(),
"{who} `{}`: {found:?} hold credentials, which no generic view may render or accept; \
drop them from the view's field lists, or serve them from a handler of your own",
schema.table
);
}
#[cfg(all(test, feature = "tenancy"))]
mod credential_tests {
use super::assert_no_credentials;
fn refusal(f: impl FnOnce()) -> String {
std::panic::catch_unwind(std::panic::AssertUnwindSafe(f))
.err()
.and_then(|e| e.downcast_ref::<String>().cloned())
.unwrap_or_default()
}
#[test]
fn user_hash_and_org_url_are_credentials_and_refused() {
use crate::core::Model as _;
let user = crate::tenancy::User::SCHEMA;
let org = crate::tenancy::Org::SCHEMA;
assert!(user.field("password_hash").unwrap().is_credential());
assert!(org.field("database_url").unwrap().is_credential());
assert!(
refusal(|| assert_no_credentials(user, "t", ["id", "password_hash"]))
.contains("password_hash")
);
assert!(
refusal(|| assert_no_credentials(org, "t", ["database_url"])).contains("database_url")
);
assert_no_credentials(user, "t", ["id", "username", "email"]);
}
}
#[cfg(all(test, feature = "tenancy"))]
mod tests {
use super::{table_access, TableAccess};
#[test]
fn identity_and_grant_tables_are_admin_only() {
for t in [
"rustango_operators",
"rustango_admin_users",
"rustango_api_keys",
#[cfg(feature = "mcp")]
"rustango_agent_grants",
#[cfg(feature = "mcp")]
"rustango_agents",
] {
assert_eq!(table_access(t), Some(TableAccess::AdminOnly), "{t}");
}
}
#[test]
fn listed_tables_keep_their_level() {
use crate::core::Model;
let mut expect = vec![
(
<crate::tenancy::DbServer as Model>::SCHEMA,
TableAccess::Never,
),
(
<crate::tenancy::TenantDatabase as Model>::SCHEMA,
TableAccess::Never,
),
(
<crate::tenancy::Operator as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::tenancy::auth_backends::ApiKey as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::tenancy::UsedJti as Model>::SCHEMA,
TableAccess::Never,
),
];
#[cfg(feature = "admin")]
expect.push((
<crate::admin::user::AdminUser as Model>::SCHEMA,
TableAccess::AdminOnly,
));
#[cfg(all(feature = "admin", feature = "totp"))]
expect.push((
<crate::admin::totp_store::AdminTotp as Model>::SCHEMA,
TableAccess::Never,
));
#[cfg(feature = "totp")]
expect.push((
<crate::tenancy::OperatorTotp as Model>::SCHEMA,
TableAccess::Never,
));
#[cfg(feature = "passkey")]
expect.push((
<crate::passkey::WebauthnCredential as Model>::SCHEMA,
TableAccess::Never,
));
#[cfg(feature = "mcp")]
expect.extend([
(
<crate::tenancy::Agent as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::tenancy::AgentGrant as Model>::SCHEMA,
TableAccess::AdminOnly,
),
]);
#[cfg(feature = "sso")]
expect.extend([
(
<crate::sso::SsoProvider as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::sso::SsoLink as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::sso::policy::SsoInvite as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::sso::policy::SsoSharedOverride as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::sso::policy::SsoTenantPolicy as Model>::SCHEMA,
TableAccess::AdminOnly,
),
(
<crate::sso::policy::SsoLandingRule as Model>::SCHEMA,
TableAccess::AdminOnly,
),
]);
#[cfg(feature = "admin-sso")]
expect.push((
<crate::tenancy::sso::SharedSsoProvider as Model>::SCHEMA,
TableAccess::AdminOnly,
));
for (schema, level) in expect {
assert_eq!(table_access(schema.table), Some(level), "{}", schema.table);
}
}
#[test]
fn table_lookup_ignores_case() {
assert_eq!(
table_access("Rustango_Operators"),
Some(TableAccess::AdminOnly)
);
}
#[test]
fn an_unknown_table_has_no_level() {
assert_eq!(table_access("no_such_table_anywhere"), None);
}
}