use rustango::core::Column as _;
use rustango::sql::{sqlx, Auto, ExecError, FetcherPool as _};
use rustango::tenancy::{Org, TenantPools};
use crate::page_type::{registered_handlers, PageTypeHandler};
use crate::page_type_model::PageType;
#[derive(Debug, thiserror::Error)]
pub enum SeedError {
#[error(transparent)]
Tenancy(#[from] rustango::tenancy::TenancyError),
#[error(transparent)]
Db(#[from] ExecError),
#[error(transparent)]
Sqlx(#[from] sqlx::Error),
#[error("{0}")]
Seeder(String),
}
pub async fn ensure_seeded(registry: &rustango::sql::Pool) -> Result<(), SeedError> {
crate::task_queue::set_registry(registry.clone());
crate::security_log::install();
match registry {
#[cfg(feature = "postgres")]
rustango::sql::Pool::Postgres(pg) => {
seed_orgs(TenantPools::<sqlx::Postgres>::new(pg.clone())).await
}
#[cfg(feature = "sqlite")]
rustango::sql::Pool::Sqlite(sq) => {
seed_orgs(TenantPools::<sqlx::Sqlite>::new(sq.clone())).await
}
#[cfg(feature = "mysql")]
rustango::sql::Pool::Mysql(my) => {
seed_orgs(TenantPools::<sqlx::MySql>::new(my.clone())).await
}
}
}
async fn seed_orgs<DB>(pools: TenantPools<DB>) -> Result<(), SeedError>
where
DB: sqlx::Database,
rustango::sql::Pool: From<sqlx::Pool<DB>>,
{
let registry_pool = pools.registry_pool();
let orgs: Vec<Org> = Org::objects().fetch(®istry_pool).await?;
let mut first_err = None;
for org in orgs {
if !org.active {
continue;
}
let seeded = match pools.scoped_pool_dyn(&org).await {
Ok(tenant_pool) => seed_tenant(&tenant_pool, &org).await,
Err(e) => Err(e.into()),
};
match seeded {
Ok(()) => mark_seeded(&org.slug),
Err(e) => {
tracing::error!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "tenant seed failed");
first_err.get_or_insert(e);
}
}
}
first_err.map_or(Ok(()), Err)
}
static SEEDED: std::sync::Mutex<Option<std::collections::HashSet<String>>> =
std::sync::Mutex::new(None);
fn mark_seeded(slug: &str) {
let mut g = SEEDED.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
g.get_or_insert_with(Default::default).insert(slug.to_owned());
}
fn is_seeded(slug: &str) -> bool {
let g = SEEDED.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
g.as_ref().is_some_and(|set| set.contains(slug))
}
pub async fn ensure_tenant_seeded(pool: &rustango::sql::Pool, org: &Org) -> Result<(), SeedError> {
if is_seeded(&org.slug) {
return Ok(());
}
static LOCK: rustango::__private_runtime::tokio::sync::Mutex<()> =
rustango::__private_runtime::tokio::sync::Mutex::const_new(());
let _held = LOCK.lock().await;
if is_seeded(&org.slug) {
return Ok(());
}
seed_tenant(pool, org).await?;
mark_seeded(&org.slug);
tracing::info!(target: "rustango_cms::seed", tenant = %org.slug, "seeded a tenant provisioned after boot");
Ok(())
}
pub(crate) async fn lazy_seed_layer(
req: axum::http::Request<axum::body::Body>,
next: axum::middleware::Next,
) -> axum::response::Response {
use rustango::tenancy::OrgResolver as _;
let (mut parts, body) = req.into_parts();
if let Some(ctx) = parts
.extensions
.get::<std::sync::Arc<rustango::extractors::TenantContext>>()
.cloned()
{
if let Ok(Some(org)) = ctx.resolver.resolve(&mut parts, &ctx.pools.registry_pool()).await {
if !is_seeded(&org.slug) {
match ctx.pools.scoped_pool_dyn(&org).await {
Ok(pool) => {
if let Err(e) = ensure_tenant_seeded(&pool, &org).await {
tracing::error!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "lazy tenant seed failed");
}
}
Err(e) => tracing::warn!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "tenant pool unavailable for seeding"),
}
}
}
}
next.run(axum::http::Request::from_parts(parts, body)).await
}
pub async fn seed_tenant(tenant_pool: &rustango::sql::Pool, org: &Org) -> Result<(), SeedError> {
let tenant_pool = tenant_pool.clone();
match crate::mysql_text::exact_identity_columns(&tenant_pool).await {
Ok(0) => {}
Ok(n) => tracing::info!(target: "rustango_cms::seed", columns = n, "gave identity columns a case-sensitive collation"),
Err(e) => tracing::warn!(target: "rustango_cms::seed", error = %e, "could not set a case-sensitive collation on identity columns"),
}
for handler in registered_handlers() {
upsert_page_type(&tenant_pool, handler.as_ref()).await?;
}
for handler in crate::library::registered_handlers() {
crate::library::ensure_library_type_row(&tenant_pool, handler.as_ref()).await?;
}
for handler in crate::category::registered_handlers() {
if let Err(e) = crate::category::upsert_taxonomy(&tenant_pool, handler.as_ref()).await {
tracing::warn!(
target: "rustango_cms::seed",
taxonomy = handler.slug(), error = %e,
"taxonomy upsert failed — has `migrate-tenants` created cms_taxonomy?"
);
}
}
crate::theme_seed::ensure_themes_seeded(&tenant_pool).await?;
if let Err(e) = reconcile_form_notification_targets(&tenant_pool).await {
tracing::warn!(
target: "rustango_cms::seed",
error = %e,
"could not reconcile form notification targets"
);
}
ensure_root_media_collection(&tenant_pool).await?;
ensure_default_roles(&tenant_pool).await?;
ensure_default_locale(&tenant_pool).await?;
crate::forms::submit::ensure_table(&tenant_pool).await?;
crate::error_pages::ensure_table(&tenant_pool).await?;
if let Err(e) = crate::revision::ensure_unique_sequence(&tenant_pool).await {
tracing::warn!(target: "rustango_cms::seed", error = %e, "revision sequence index not created");
}
crate::redirect::ensure_columns(&tenant_pool).await?;
crate::analytics::ensure_table(&tenant_pool).await?;
let retain = crate::analytics::retention::retention_days(&tenant_pool).await;
if let Err(e) = crate::analytics::retention::prune(&tenant_pool, retain).await {
tracing::warn!(error = %e, "analytics retention prune failed");
}
if let Err(e) = crate::search::ensure_pg_fts_index(&tenant_pool).await {
tracing::warn!(error = %e, "full-text search index not created");
}
rustango::i18n::db::ensure_table_pool(&tenant_pool).await?;
if let Err(e) = ensure_mcp_skills(&tenant_pool).await {
tracing::warn!(error = %e, "mcp skill seeding failed");
}
if let Some(templates) = crate::tenant_templates::installed() {
match crate::tenant_templates::database_birth(&tenant_pool).await {
Ok(Some(owner)) => match templates.claim(&org.slug, &owner) {
Ok(crate::tenant_templates::Claim::MovedAside { previous_owner, to }) => {
tracing::warn!(
target: "rustango_cms::seed",
tenant = %org.slug, previous_owner, to = %to.display(),
"template overrides belonged to an earlier tenant with this slug; moved aside"
);
}
Ok(_) => {}
Err(e) => tracing::warn!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "could not claim template overrides"),
},
Ok(None) => {}
Err(e) => tracing::warn!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "could not read the database's identity"),
}
}
fire_tenant_seeders(&tenant_pool, &org).await?;
match crate::mysql_text::widen_long_text(&tenant_pool).await {
Ok(0) => {}
Ok(n) => tracing::info!(target: "rustango_cms::seed", columns = n, "widened TEXT columns to LONGTEXT"),
Err(e) => tracing::warn!(target: "rustango_cms::seed", error = %e, "could not widen TEXT columns"),
}
Ok(())
}
pub type SeedFuture<'a> =
std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), SeedError>> + Send + 'a>>;
#[derive(Clone, Copy)]
pub struct TenantSeeder(pub for<'a> fn(&'a rustango::sql::Pool, &'a Org) -> SeedFuture<'a>);
inventory::collect!(TenantSeeder);
#[macro_export]
macro_rules! register_tenant_seeder {
($f:expr) => {
::rustango_cms::inventory::submit! {
$crate::seed::TenantSeeder($f)
}
};
}
async fn fire_tenant_seeders(
pool: &rustango::sql::Pool,
org: &Org,
) -> Result<(), SeedError> {
for seeder in inventory::iter::<TenantSeeder>() {
(seeder.0)(pool, org).await?;
}
Ok(())
}
pub async fn grant_codename(
pool: &rustango::sql::Pool,
role_name: &str,
codename: &str,
) -> Result<(), ExecError> {
backfill_codename(pool, role_name, codename).await
}
type McpSkillSpec = (
&'static str,
&'static str,
&'static str,
&'static str,
&'static [&'static str],
&'static [&'static str],
);
const MCP_SKILLS: &[McpSkillSpec] = &[
(
"cms-read",
"CMS read",
"Browse page types, pages, media, snippets, locales, and translatable fields.",
"You are working inside this site's CMS. Discover structure with \
list_page_types before writing; read existing content before \
changing it.",
&[
"list_page_types",
"search_pages",
"get_page",
"list_locales",
"list_media",
"list_collections",
"list_snippets",
"list_translatable_fields",
],
&["cms_page.view"],
),
(
"cms-write",
"CMS write",
"Create and edit pages, upload media, put media onto a page, and \
manage snippets.",
"Create drafts unless the user explicitly asks to publish. Reuse \
existing media via list_media before uploading duplicates. \
Uploading a file only files it in the library — call attach_media \
to actually put it on a page, either into a chooser field or as an \
image block in the body (list_page_types names both).",
&[
"create_page",
"update_page",
"upload_media",
"attach_media",
"upsert_snippet",
],
&["cms_page.edit", "cms_page.add"],
),
(
"cms-publish",
"CMS publish",
"Publish pages to the live site.",
"Publishing makes content live immediately — confirm intent before \
calling publish_page.",
&["publish_page"],
&["cms_page.publish"],
),
(
"cms-templates",
"CMS templates",
"Read, create and modify this site's templates, and choose which \
template a page type renders with.",
"Templates are Tera. Read the inherited body before customising a \
template — editing one creates a copy for this site and leaves the \
shared version alone. validate_template checks a body without \
writing it; prefer it while iterating. There is deliberately no \
delete tool: reverting a customisation is left to a person in the \
admin, so if a template should stop doing something, rewrite it.",
&[
"list_templates",
"read_template",
"write_template",
"validate_template",
"set_page_type_template",
],
&[crate::admin::TEMPLATE_EDIT_CODENAME],
),
(
"cms-translate",
"CMS translate",
"Write translation overrides for pages in any non-default locale.",
"Use list_translatable_fields to get the exact field paths and \
canonical text; translate faithfully and keep markup intact.",
&["upsert_translations"],
&["cms_page.edit"],
),
];
pub async fn ensure_mcp_skills(pool: &rustango::sql::Pool) -> Result<(), rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
use rustango::tenancy::{AgentSkill, AgentSkillTool};
for (codename, name, description, instructions, tools, perms) in MCP_SKILLS {
let tool_names: Vec<String> = tools.iter().map(|t| (*t).to_owned()).collect();
match rustango::tenancy::create_skill_pool(
pool,
codename,
name,
description,
instructions,
&tool_names,
)
.await
{
Ok(_) => {}
Err(rustango::tenancy::AgentError::Duplicate(_)) => {
let skill: Option<AgentSkill> = AgentSkill::objects()
.where_(AgentSkill::codename.eq((*codename).to_owned()))
.first(pool)
.await?;
let Some(skill) = skill else { continue };
let skill_id = skill.id.get().copied().unwrap_or_default();
let existing: Vec<AgentSkillTool> = AgentSkillTool::objects()
.where_(AgentSkillTool::skill_id.eq(skill_id))
.fetch(pool)
.await?;
for tool in *tools {
if !existing.iter().any(|t| t.tool_name == *tool) {
let mut row = AgentSkillTool {
id: rustango::sql::Auto::Unset,
skill_id,
tool_name: (*tool).to_owned(),
};
row.insert_pool(pool).await?;
}
}
}
Err(e) => {
tracing::warn!(skill = codename, error = %e, "mcp skill create failed");
continue;
}
}
for perm in *perms {
if let Err(e) =
rustango::tenancy::map_skill_to_permission_pool(pool, codename, perm).await
{
tracing::warn!(skill = codename, perm, error = %e, "skill-permission map failed");
}
}
}
Ok(())
}
async fn ensure_default_roles(pool: &rustango::sql::Pool) -> Result<(), ExecError> {
use crate::admin::resources::{all_resources, codename};
use crate::permissions::Action;
let resources = all_resources();
let collect = |pred: &dyn Fn(&crate::admin::resources::AdminResource, Action) -> bool| {
let mut out: Vec<String> = Vec::new();
let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
for r in &resources {
for action in r.actions {
if pred(r, *action) {
let code = codename(r, *action);
if seen.insert(code.clone()) {
out.push(code);
}
}
}
}
out
};
let viewer_codes = collect(&|r, a| {
(a == Action::View
&& r.codename_prefix != "rustango_users"
&& r.codename_prefix != "rustango_roles")
|| (a == Action::Access && r.codename_prefix == "cms_admin")
});
let editor_codes = collect(&|r, a| {
if r.codename_prefix == "rustango_users" || r.codename_prefix == "rustango_roles" {
return false;
}
if r.codename_prefix == "cms_admin" {
return a == Action::Access;
}
if r.codename_prefix == "auth" {
return false;
}
match r.codename_prefix.as_str() {
"cms_locale" | "cms_page_type" | "cms_history" => a == Action::View,
"cms_settings" => matches!(a, Action::View | Action::Edit),
_ => matches!(a, Action::View | Action::Add | Action::Edit),
}
});
let admin_codes = collect(&|_r, _a| true);
seed_role_with_codenames(
pool,
"Viewer",
"Read-only access across the admin.",
&viewer_codes,
)
.await?;
seed_role_with_codenames(
pool,
"Editor",
"Create / edit content, media, redirects, navigation. No access to users or roles.",
&editor_codes,
)
.await?;
seed_role_with_codenames(
pool,
"Administrator",
"Full access across every admin section.",
&admin_codes,
)
.await?;
let mut dev_codes = viewer_codes.clone();
dev_codes.push("cms_page_type.build".to_owned());
dev_codes.push(crate::admin::TEMPLATE_EDIT_CODENAME.to_owned());
dev_codes.push(crate::admin::NOTIFICATION_MANAGE_CODENAME.to_owned());
dev_codes.push(crate::admin::SITE_MANAGE_CODENAME.to_owned());
seed_role_with_codenames(
pool,
"Developer",
"Content modelling: build page-type field schemas + reusable components.",
&dev_codes,
)
.await?;
backfill_codename(pool, "Viewer", "cms_admin.access").await?;
backfill_codename(pool, "Editor", "cms_admin.access").await?;
backfill_codename(pool, "Administrator", "cms_admin.access").await?;
backfill_codename(pool, "Administrator", "auth.access_admin").await?;
backfill_codename(pool, "Developer", "cms_admin.access").await?;
backfill_codename(pool, "Developer", "cms_page_type.build").await?;
backfill_codename(pool, "Administrator", "cms_page_type.build").await?;
backfill_codename(pool, "Developer", crate::admin::TEMPLATE_EDIT_CODENAME).await?;
backfill_codename(pool, "Administrator", crate::admin::TEMPLATE_EDIT_CODENAME).await?;
backfill_codename(pool, "Developer", crate::admin::NOTIFICATION_MANAGE_CODENAME).await?;
backfill_codename(pool, "Administrator", crate::admin::NOTIFICATION_MANAGE_CODENAME).await?;
backfill_codename(pool, "Developer", crate::admin::SITE_MANAGE_CODENAME).await?;
backfill_codename(pool, "Administrator", crate::admin::SITE_MANAGE_CODENAME).await?;
Ok(())
}
async fn backfill_codename(
pool: &rustango::sql::Pool,
role_name: &str,
codename: &str,
) -> Result<(), ExecError> {
use rustango::core::Column as _;
let role: Option<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.where_(rustango::tenancy::permissions::Role::name.eq(role_name.to_owned()))
.first(pool)
.await?;
let Some(role) = role else {
return Ok(());
};
let role_id = role.id.get().copied().unwrap_or_default();
let existing: Vec<rustango::tenancy::permissions::RolePermission> =
rustango::tenancy::permissions::RolePermission::objects()
.where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
.where_(
rustango::tenancy::permissions::RolePermission::codename.eq(codename.to_owned()),
)
.fetch(pool)
.await?;
if !existing.is_empty() {
return Ok(());
}
let mut perm = rustango::tenancy::permissions::RolePermission {
id: Auto::Unset,
role_id,
codename: codename.to_owned(),
};
perm.insert_pool(pool).await?;
Ok(())
}
async fn seed_role_with_codenames(
pool: &rustango::sql::Pool,
name: &str,
description: &str,
codenames: &[String],
) -> Result<(), ExecError> {
use rustango::core::Column as _;
let existing: Vec<rustango::tenancy::permissions::Role> =
rustango::tenancy::permissions::Role::objects()
.where_(rustango::tenancy::permissions::Role::name.eq(name.to_owned()))
.fetch(pool)
.await?;
if existing.into_iter().next().is_some() {
return Ok(());
}
let mut row = rustango::tenancy::permissions::Role {
id: Auto::Unset,
name: name.to_owned(),
description: description.to_owned(),
data: serde_json::Value::Object(serde_json::Map::new()),
};
row.insert_pool(pool).await?;
let role_id = row.id.get().copied().unwrap_or_default();
let mut seen: std::collections::HashSet<&str> = std::collections::HashSet::new();
for codename in codenames {
if !seen.insert(codename.as_str()) {
continue;
}
let mut perm = rustango::tenancy::permissions::RolePermission {
id: Auto::Unset,
role_id,
codename: codename.clone(),
};
perm.insert_pool(pool).await?;
}
Ok(())
}
async fn ensure_default_locale(pool: &rustango::sql::Pool) -> Result<(), ExecError> {
let existing: Vec<crate::locale::Locale> = crate::locale::Locale::objects().fetch(pool).await?;
if !existing.is_empty() {
return Ok(());
}
let mut row = crate::locale::Locale {
id: Auto::Unset,
code: "en".to_owned(),
name: "English".to_owned(),
is_default: true,
active: true,
sort_order: 0,
created_at: Auto::Unset,
};
row.insert_pool(pool).await?;
Ok(())
}
async fn ensure_root_media_collection(pool: &rustango::sql::Pool) -> Result<(), ExecError> {
let existing: Vec<crate::media::MediaCollection> =
crate::media::MediaCollection::objects().fetch(pool).await?;
if !existing.is_empty() {
return Ok(());
}
let mut row = crate::media::MediaCollection {
id: Auto::Unset,
name: "Root".to_owned(),
parent_id: None,
sort_order: 0,
created_at: Auto::Unset,
};
row.insert_pool(pool).await?;
Ok(())
}
async fn upsert_page_type(
pool: &rustango::sql::Pool,
handler: &dyn PageTypeHandler,
) -> Result<(), ExecError> {
let parents_json = serde_json::to_value(handler.allowed_parent_types())
.unwrap_or(serde_json::Value::Array(Vec::new()));
let children_json = serde_json::to_value(handler.allowed_child_types())
.unwrap_or(serde_json::Value::Array(Vec::new()));
let mut existing: Vec<PageType> = PageType::objects()
.where_(PageType::type_name.eq(handler.type_name().to_string()))
.fetch(pool)
.await?;
if let Some(mut row) = existing.pop() {
row.app_label = handler.app_label().to_owned();
row.verbose_name = handler.verbose_name().to_owned();
row.default_template = handler.default_template().to_owned();
row.view_mode = handler.view_mode().as_str().to_owned();
row.is_creatable = handler.is_creatable();
row.allowed_parent_types = parents_json;
row.allowed_child_types = children_json;
row.workflow = handler.workflow_slug().unwrap_or_default().to_owned();
row.save_pool(pool).await?;
} else {
let mut row = PageType {
id: Auto::Unset,
app_label: handler.app_label().to_owned(),
type_name: handler.type_name().to_owned(),
verbose_name: handler.verbose_name().to_owned(),
default_template: handler.default_template().to_owned(),
view_mode: handler.view_mode().as_str().to_owned(),
is_creatable: handler.is_creatable(),
allowed_parent_types: parents_json,
allowed_child_types: children_json,
workflow: handler.workflow_slug().unwrap_or_default().to_owned(),
created_at: Auto::Unset,
updated_at: Auto::Unset,
};
row.insert_pool(pool).await?;
}
Ok(())
}
async fn reconcile_form_notification_targets(
pool: &rustango::sql::Pool,
) -> Result<(), rustango::sql::ExecError> {
use rustango::core::Column as _;
use rustango::sql::FetcherPool as _;
let forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
.where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
.fetch(pool)
.await?;
for f in forms {
let id = f.id.get().copied().unwrap_or_default();
let parsed = crate::forms::schema::parse_draft(&f.data);
crate::notify::targets::sync_form_email(
pool,
id,
&f.title,
&parsed.settings.notify_emails,
)
.await?;
}
Ok(())
}
#[cfg(all(test, feature = "sqlite"))]
mod tests {
use super::*;
use rustango::core::Model as _;
use rustango::sql::Pool;
use rustango::tenancy::permissions::{Role, RolePermission};
async fn mem_pool() -> Pool {
let pool = Pool::connect("sqlite::memory:")
.await
.expect("in-memory sqlite");
for schema in [&Role::SCHEMA, &RolePermission::SCHEMA] {
let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
pool.dialect(),
schema,
);
for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
.await
.expect("ddl");
}
}
pool
}
#[tokio::test]
async fn a_repeated_codename_is_granted_once() {
let pool = mem_pool().await;
seed_role_with_codenames(
&pool,
"Administrator",
"every codename",
&[
"rpt_connection.view".to_owned(),
"cms_page.view".to_owned(),
"rpt_connection.view".to_owned(),
],
)
.await
.expect("seeding a role must tolerate a repeated codename");
let role: Role = Role::objects()
.where_(Role::name.eq("Administrator".to_owned()))
.first(&pool)
.await
.expect("query")
.expect("the role was created");
let role_id = role.id.get().copied().unwrap_or_default();
let granted: Vec<RolePermission> = RolePermission::objects()
.where_(RolePermission::role_id.eq(role_id))
.fetch(&pool)
.await
.expect("query");
assert_eq!(granted.len(), 2, "one row per distinct codename");
let mut codes: Vec<&str> = granted.iter().map(|p| p.codename.as_str()).collect();
codes.sort_unstable();
assert_eq!(codes, ["cms_page.view", "rpt_connection.view"]);
}
}