1use rustango::core::Column as _;
14use rustango::sql::{sqlx, Auto, ExecError, FetcherPool as _};
15use rustango::tenancy::{Org, TenantPools};
16
17use crate::page_type::{registered_handlers, PageTypeHandler};
18use crate::page_type_model::PageType;
19
20#[derive(Debug, thiserror::Error)]
23pub enum SeedError {
24 #[error(transparent)]
25 Tenancy(#[from] rustango::tenancy::TenancyError),
26 #[error(transparent)]
27 Db(#[from] ExecError),
28 #[error(transparent)]
29 Sqlx(#[from] sqlx::Error),
30
31 #[error("{0}")]
37 Seeder(String),
38}
39
40pub async fn ensure_seeded(registry: &rustango::sql::Pool) -> Result<(), SeedError> {
64 crate::task_queue::set_registry(registry.clone());
66 crate::security_log::install();
68 match registry {
69 #[cfg(feature = "postgres")]
70 rustango::sql::Pool::Postgres(pg) => {
71 seed_orgs(TenantPools::<sqlx::Postgres>::new(pg.clone())).await
72 }
73 #[cfg(feature = "sqlite")]
74 rustango::sql::Pool::Sqlite(sq) => {
75 seed_orgs(TenantPools::<sqlx::Sqlite>::new(sq.clone())).await
76 }
77 #[cfg(feature = "mysql")]
78 rustango::sql::Pool::Mysql(my) => {
79 seed_orgs(TenantPools::<sqlx::MySql>::new(my.clone())).await
80 }
81 }
82}
83
84async fn seed_orgs<DB>(pools: TenantPools<DB>) -> Result<(), SeedError>
85where
86 DB: sqlx::Database,
87 rustango::sql::Pool: From<sqlx::Pool<DB>>,
88{
89 let registry_pool = pools.registry_pool();
90 let orgs: Vec<Org> = Org::objects().fetch(®istry_pool).await?;
91
92 let mut first_err = None;
95 for org in orgs {
96 if !org.active {
97 continue;
98 }
99 let seeded = match pools.scoped_pool_dyn(&org).await {
100 Ok(tenant_pool) => seed_tenant(&tenant_pool, &org).await,
101 Err(e) => Err(e.into()),
102 };
103 match seeded {
104 Ok(()) => mark_seeded(&org.slug),
105 Err(e) => {
106 tracing::error!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "tenant seed failed");
107 first_err.get_or_insert(e);
108 }
109 }
110 }
111 first_err.map_or(Ok(()), Err)
112}
113
114static SEEDED: std::sync::Mutex<Option<std::collections::HashSet<String>>> =
116 std::sync::Mutex::new(None);
117
118fn mark_seeded(slug: &str) {
119 let mut g = SEEDED.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
120 g.get_or_insert_with(Default::default).insert(slug.to_owned());
121}
122
123fn is_seeded(slug: &str) -> bool {
124 let g = SEEDED.lock().unwrap_or_else(std::sync::PoisonError::into_inner);
125 g.as_ref().is_some_and(|set| set.contains(slug))
126}
127
128pub async fn ensure_tenant_seeded(pool: &rustango::sql::Pool, org: &Org) -> Result<(), SeedError> {
139 if is_seeded(&org.slug) {
140 return Ok(());
141 }
142 static LOCK: rustango::__private_runtime::tokio::sync::Mutex<()> =
143 rustango::__private_runtime::tokio::sync::Mutex::const_new(());
144 let _held = LOCK.lock().await;
145 if is_seeded(&org.slug) {
146 return Ok(());
147 }
148 seed_tenant(pool, org).await?;
149 mark_seeded(&org.slug);
150 tracing::info!(target: "rustango_cms::seed", tenant = %org.slug, "seeded a tenant provisioned after boot");
151 Ok(())
152}
153
154pub(crate) async fn lazy_seed_layer(
159 req: axum::http::Request<axum::body::Body>,
160 next: axum::middleware::Next,
161) -> axum::response::Response {
162 use rustango::tenancy::OrgResolver as _;
163 let (mut parts, body) = req.into_parts();
164 if let Some(ctx) = parts
165 .extensions
166 .get::<std::sync::Arc<rustango::extractors::TenantContext>>()
167 .cloned()
168 {
169 if let Ok(Some(org)) = ctx.resolver.resolve(&mut parts, &ctx.pools.registry_pool()).await {
170 if !is_seeded(&org.slug) {
171 match ctx.pools.scoped_pool_dyn(&org).await {
172 Ok(pool) => {
173 if let Err(e) = ensure_tenant_seeded(&pool, &org).await {
174 tracing::error!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "lazy tenant seed failed");
175 }
176 }
177 Err(e) => tracing::warn!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "tenant pool unavailable for seeding"),
178 }
179 }
180 }
181 }
182 next.run(axum::http::Request::from_parts(parts, body)).await
183}
184
185pub async fn seed_tenant(tenant_pool: &rustango::sql::Pool, org: &Org) -> Result<(), SeedError> {
194 let tenant_pool = tenant_pool.clone();
195 match crate::mysql_text::exact_identity_columns(&tenant_pool).await {
200 Ok(0) => {}
201 Ok(n) => tracing::info!(target: "rustango_cms::seed", columns = n, "gave identity columns a case-sensitive collation"),
202 Err(e) => tracing::warn!(target: "rustango_cms::seed", error = %e, "could not set a case-sensitive collation on identity columns"),
203 }
204 for handler in registered_handlers() {
205 upsert_page_type(&tenant_pool, handler.as_ref()).await?;
206 }
207 for handler in crate::library::registered_handlers() {
210 crate::library::ensure_library_type_row(&tenant_pool, handler.as_ref()).await?;
211 }
212 for handler in crate::category::registered_handlers() {
219 if let Err(e) = crate::category::upsert_taxonomy(&tenant_pool, handler.as_ref()).await {
220 tracing::warn!(
221 target: "rustango_cms::seed",
222 taxonomy = handler.slug(), error = %e,
223 "taxonomy upsert failed — has `migrate-tenants` created cms_taxonomy?"
224 );
225 }
226 }
227 crate::theme_seed::ensure_themes_seeded(&tenant_pool).await?;
230 if let Err(e) = reconcile_form_notification_targets(&tenant_pool).await {
236 tracing::warn!(
237 target: "rustango_cms::seed",
238 error = %e,
239 "could not reconcile form notification targets"
240 );
241 }
242 ensure_root_media_collection(&tenant_pool).await?;
246 ensure_default_roles(&tenant_pool).await?;
252 ensure_default_locale(&tenant_pool).await?;
256 crate::forms::submit::ensure_table(&tenant_pool).await?;
259 crate::error_pages::ensure_table(&tenant_pool).await?;
263 if let Err(e) = crate::revision::ensure_unique_sequence(&tenant_pool).await {
267 tracing::warn!(target: "rustango_cms::seed", error = %e, "revision sequence index not created");
268 }
269 crate::redirect::ensure_columns(&tenant_pool).await?;
272 crate::analytics::ensure_table(&tenant_pool).await?;
275 let retain = crate::analytics::retention::retention_days(&tenant_pool).await;
276 if let Err(e) = crate::analytics::retention::prune(&tenant_pool, retain).await {
277 tracing::warn!(error = %e, "analytics retention prune failed");
278 }
279 if let Err(e) = crate::search::ensure_pg_fts_index(&tenant_pool).await {
284 tracing::warn!(error = %e, "full-text search index not created");
285 }
286 rustango::i18n::db::ensure_table_pool(&tenant_pool).await?;
291 if let Err(e) = ensure_mcp_skills(&tenant_pool).await {
295 tracing::warn!(error = %e, "mcp skill seeding failed");
296 }
297 if let Some(templates) = crate::tenant_templates::installed() {
301 match crate::tenant_templates::database_birth(&tenant_pool).await {
302 Ok(Some(owner)) => match templates.claim(&org.slug, &owner) {
303 Ok(crate::tenant_templates::Claim::MovedAside { previous_owner, to }) => {
304 tracing::warn!(
305 target: "rustango_cms::seed",
306 tenant = %org.slug, previous_owner, to = %to.display(),
307 "template overrides belonged to an earlier tenant with this slug; moved aside"
308 );
309 }
310 Ok(_) => {}
311 Err(e) => tracing::warn!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "could not claim template overrides"),
312 },
313 Ok(None) => {}
314 Err(e) => tracing::warn!(target: "rustango_cms::seed", tenant = %org.slug, error = %e, "could not read the database's identity"),
315 }
316 }
317 fire_tenant_seeders(&tenant_pool, &org).await?;
321 match crate::mysql_text::widen_long_text(&tenant_pool).await {
325 Ok(0) => {}
326 Ok(n) => tracing::info!(target: "rustango_cms::seed", columns = n, "widened TEXT columns to LONGTEXT"),
327 Err(e) => tracing::warn!(target: "rustango_cms::seed", error = %e, "could not widen TEXT columns"),
328 }
329 Ok(())
330}
331
332pub type SeedFuture<'a> =
338 std::pin::Pin<Box<dyn std::future::Future<Output = Result<(), SeedError>> + Send + 'a>>;
339
340#[derive(Clone, Copy)]
369pub struct TenantSeeder(pub for<'a> fn(&'a rustango::sql::Pool, &'a Org) -> SeedFuture<'a>);
370
371inventory::collect!(TenantSeeder);
372
373#[macro_export]
379macro_rules! register_tenant_seeder {
380 ($f:expr) => {
381 ::rustango_cms::inventory::submit! {
382 $crate::seed::TenantSeeder($f)
383 }
384 };
385}
386
387async fn fire_tenant_seeders(
393 pool: &rustango::sql::Pool,
394 org: &Org,
395) -> Result<(), SeedError> {
396 for seeder in inventory::iter::<TenantSeeder>() {
397 (seeder.0)(pool, org).await?;
398 }
399 Ok(())
400}
401
402pub async fn grant_codename(
416 pool: &rustango::sql::Pool,
417 role_name: &str,
418 codename: &str,
419) -> Result<(), ExecError> {
420 backfill_codename(pool, role_name, codename).await
421}
422
423type McpSkillSpec = (
427 &'static str,
428 &'static str,
429 &'static str,
430 &'static str,
431 &'static [&'static str],
432 &'static [&'static str],
433);
434
435const MCP_SKILLS: &[McpSkillSpec] = &[
436 (
437 "cms-read",
438 "CMS read",
439 "Browse page types, pages, media, snippets, locales, and translatable fields.",
440 "You are working inside this site's CMS. Discover structure with \
441 list_page_types before writing; read existing content before \
442 changing it.",
443 &[
444 "list_page_types",
445 "search_pages",
446 "get_page",
447 "list_locales",
448 "list_media",
449 "list_collections",
450 "list_snippets",
451 "list_translatable_fields",
452 ],
453 &["cms_page.view"],
454 ),
455 (
456 "cms-write",
457 "CMS write",
458 "Create and edit pages, upload media, put media onto a page, and \
459 manage snippets.",
460 "Create drafts unless the user explicitly asks to publish. Reuse \
461 existing media via list_media before uploading duplicates. \
462 Uploading a file only files it in the library — call attach_media \
463 to actually put it on a page, either into a chooser field or as an \
464 image block in the body (list_page_types names both).",
465 &[
466 "create_page",
467 "update_page",
468 "upload_media",
469 "attach_media",
470 "upsert_snippet",
471 ],
472 &["cms_page.edit", "cms_page.add"],
473 ),
474 (
475 "cms-publish",
476 "CMS publish",
477 "Publish pages to the live site.",
478 "Publishing makes content live immediately — confirm intent before \
479 calling publish_page.",
480 &["publish_page"],
481 &["cms_page.publish"],
482 ),
483 (
484 "cms-templates",
485 "CMS templates",
486 "Read, create and modify this site's templates, and choose which \
487 template a page type renders with.",
488 "Templates are Tera. Read the inherited body before customising a \
489 template — editing one creates a copy for this site and leaves the \
490 shared version alone. validate_template checks a body without \
491 writing it; prefer it while iterating. There is deliberately no \
492 delete tool: reverting a customisation is left to a person in the \
493 admin, so if a template should stop doing something, rewrite it.",
494 &[
495 "list_templates",
496 "read_template",
497 "write_template",
498 "validate_template",
499 "set_page_type_template",
500 ],
501 &[crate::admin::TEMPLATE_EDIT_CODENAME],
502 ),
503 (
504 "cms-translate",
505 "CMS translate",
506 "Write translation overrides for pages in any non-default locale.",
507 "Use list_translatable_fields to get the exact field paths and \
508 canonical text; translate faithfully and keep markup intact.",
509 &["upsert_translations"],
510 &["cms_page.edit"],
511 ),
512];
513
514pub async fn ensure_mcp_skills(pool: &rustango::sql::Pool) -> Result<(), rustango::sql::ExecError> {
520 use rustango::core::Column as _;
521 use rustango::sql::FetcherPool as _;
522 use rustango::tenancy::{AgentSkill, AgentSkillTool};
523
524 for (codename, name, description, instructions, tools, perms) in MCP_SKILLS {
525 let tool_names: Vec<String> = tools.iter().map(|t| (*t).to_owned()).collect();
526 match rustango::tenancy::create_skill_pool(
527 pool,
528 codename,
529 name,
530 description,
531 instructions,
532 &tool_names,
533 )
534 .await
535 {
536 Ok(_) => {}
537 Err(rustango::tenancy::AgentError::Duplicate(_)) => {
538 let skill: Option<AgentSkill> = AgentSkill::objects()
540 .where_(AgentSkill::codename.eq((*codename).to_owned()))
541 .first(pool)
542 .await?;
543 let Some(skill) = skill else { continue };
544 let skill_id = skill.id.get().copied().unwrap_or_default();
545 let existing: Vec<AgentSkillTool> = AgentSkillTool::objects()
546 .where_(AgentSkillTool::skill_id.eq(skill_id))
547 .fetch(pool)
548 .await?;
549 for tool in *tools {
550 if !existing.iter().any(|t| t.tool_name == *tool) {
551 let mut row = AgentSkillTool {
552 id: rustango::sql::Auto::Unset,
553 skill_id,
554 tool_name: (*tool).to_owned(),
555 };
556 row.insert_pool(pool).await?;
557 }
558 }
559 }
560 Err(e) => {
561 tracing::warn!(skill = codename, error = %e, "mcp skill create failed");
562 continue;
563 }
564 }
565 for perm in *perms {
566 if let Err(e) =
567 rustango::tenancy::map_skill_to_permission_pool(pool, codename, perm).await
568 {
569 tracing::warn!(skill = codename, perm, error = %e, "skill-permission map failed");
570 }
571 }
572 }
573 Ok(())
574}
575
576async fn ensure_default_roles(pool: &rustango::sql::Pool) -> Result<(), ExecError> {
589 use crate::admin::resources::{all_resources, codename};
590 use crate::permissions::Action;
591
592 let resources = all_resources();
593
594 let collect = |pred: &dyn Fn(&crate::admin::resources::AdminResource, Action) -> bool| {
603 let mut out: Vec<String> = Vec::new();
604 let mut seen: std::collections::HashSet<String> = std::collections::HashSet::new();
605 for r in &resources {
606 for action in r.actions {
607 if pred(r, *action) {
608 let code = codename(r, *action);
609 if seen.insert(code.clone()) {
610 out.push(code);
611 }
612 }
613 }
614 }
615 out
616 };
617
618 let viewer_codes = collect(&|r, a| {
619 (a == Action::View
624 && r.codename_prefix != "rustango_users"
625 && r.codename_prefix != "rustango_roles")
626 || (a == Action::Access && r.codename_prefix == "cms_admin")
627 });
628 let editor_codes = collect(&|r, a| {
629 if r.codename_prefix == "rustango_users" || r.codename_prefix == "rustango_roles" {
631 return false;
632 }
633 if r.codename_prefix == "cms_admin" {
634 return a == Action::Access;
635 }
636 if r.codename_prefix == "auth" {
639 return false;
640 }
641 match r.codename_prefix.as_str() {
642 "cms_locale" | "cms_page_type" | "cms_history" => a == Action::View,
644 "cms_settings" => matches!(a, Action::View | Action::Edit),
646 _ => matches!(a, Action::View | Action::Add | Action::Edit),
648 }
649 });
650 let admin_codes = collect(&|_r, _a| true);
655
656 seed_role_with_codenames(
657 pool,
658 "Viewer",
659 "Read-only access across the admin.",
660 &viewer_codes,
661 )
662 .await?;
663 seed_role_with_codenames(
664 pool,
665 "Editor",
666 "Create / edit content, media, redirects, navigation. No access to users or roles.",
667 &editor_codes,
668 )
669 .await?;
670 seed_role_with_codenames(
671 pool,
672 "Administrator",
673 "Full access across every admin section.",
674 &admin_codes,
675 )
676 .await?;
677 let mut dev_codes = viewer_codes.clone();
682 dev_codes.push("cms_page_type.build".to_owned());
683 dev_codes.push(crate::admin::TEMPLATE_EDIT_CODENAME.to_owned());
687 dev_codes.push(crate::admin::NOTIFICATION_MANAGE_CODENAME.to_owned());
688 dev_codes.push(crate::admin::SITE_MANAGE_CODENAME.to_owned());
692 seed_role_with_codenames(
693 pool,
694 "Developer",
695 "Content modelling: build page-type field schemas + reusable components.",
696 &dev_codes,
697 )
698 .await?;
699 backfill_codename(pool, "Viewer", "cms_admin.access").await?;
704 backfill_codename(pool, "Editor", "cms_admin.access").await?;
705 backfill_codename(pool, "Administrator", "cms_admin.access").await?;
706 backfill_codename(pool, "Administrator", "auth.access_admin").await?;
711 backfill_codename(pool, "Developer", "cms_admin.access").await?;
714 backfill_codename(pool, "Developer", "cms_page_type.build").await?;
715 backfill_codename(pool, "Administrator", "cms_page_type.build").await?;
716 backfill_codename(pool, "Developer", crate::admin::TEMPLATE_EDIT_CODENAME).await?;
719 backfill_codename(pool, "Administrator", crate::admin::TEMPLATE_EDIT_CODENAME).await?;
720 backfill_codename(pool, "Developer", crate::admin::NOTIFICATION_MANAGE_CODENAME).await?;
723 backfill_codename(pool, "Administrator", crate::admin::NOTIFICATION_MANAGE_CODENAME).await?;
724 backfill_codename(pool, "Developer", crate::admin::SITE_MANAGE_CODENAME).await?;
725 backfill_codename(pool, "Administrator", crate::admin::SITE_MANAGE_CODENAME).await?;
726 Ok(())
727}
728
729async fn backfill_codename(
732 pool: &rustango::sql::Pool,
733 role_name: &str,
734 codename: &str,
735) -> Result<(), ExecError> {
736 use rustango::core::Column as _;
737 let role: Option<rustango::tenancy::permissions::Role> =
738 rustango::tenancy::permissions::Role::objects()
739 .where_(rustango::tenancy::permissions::Role::name.eq(role_name.to_owned()))
740 .first(pool)
741 .await?;
742 let Some(role) = role else {
743 return Ok(());
744 };
745 let role_id = role.id.get().copied().unwrap_or_default();
746 let existing: Vec<rustango::tenancy::permissions::RolePermission> =
747 rustango::tenancy::permissions::RolePermission::objects()
748 .where_(rustango::tenancy::permissions::RolePermission::role_id.eq(role_id))
749 .where_(
750 rustango::tenancy::permissions::RolePermission::codename.eq(codename.to_owned()),
751 )
752 .fetch(pool)
753 .await?;
754 if !existing.is_empty() {
755 return Ok(());
756 }
757 let mut perm = rustango::tenancy::permissions::RolePermission {
758 id: Auto::Unset,
759 role_id,
760 codename: codename.to_owned(),
761 };
762 perm.insert_pool(pool).await?;
763 Ok(())
764}
765
766async fn seed_role_with_codenames(
767 pool: &rustango::sql::Pool,
768 name: &str,
769 description: &str,
770 codenames: &[String],
771) -> Result<(), ExecError> {
772 use rustango::core::Column as _;
773 let existing: Vec<rustango::tenancy::permissions::Role> =
774 rustango::tenancy::permissions::Role::objects()
775 .where_(rustango::tenancy::permissions::Role::name.eq(name.to_owned()))
776 .fetch(pool)
777 .await?;
778 if existing.into_iter().next().is_some() {
779 return Ok(());
780 }
781 let mut row = rustango::tenancy::permissions::Role {
782 id: Auto::Unset,
783 name: name.to_owned(),
784 description: description.to_owned(),
785 data: serde_json::Value::Object(serde_json::Map::new()),
786 };
787 row.insert_pool(pool).await?;
788 let role_id = row.id.get().copied().unwrap_or_default();
789 let mut seen: std::collections::HashSet<&str> = std::collections::HashSet::new();
796 for codename in codenames {
797 if !seen.insert(codename.as_str()) {
798 continue;
799 }
800 let mut perm = rustango::tenancy::permissions::RolePermission {
801 id: Auto::Unset,
802 role_id,
803 codename: codename.clone(),
804 };
805 perm.insert_pool(pool).await?;
806 }
807 Ok(())
808}
809
810async fn ensure_default_locale(pool: &rustango::sql::Pool) -> Result<(), ExecError> {
817 let existing: Vec<crate::locale::Locale> = crate::locale::Locale::objects().fetch(pool).await?;
818 if !existing.is_empty() {
819 return Ok(());
820 }
821 let mut row = crate::locale::Locale {
822 id: Auto::Unset,
823 code: "en".to_owned(),
824 name: "English".to_owned(),
825 is_default: true,
826 active: true,
827 sort_order: 0,
828 created_at: Auto::Unset,
829 };
830 row.insert_pool(pool).await?;
831 Ok(())
832}
833
834async fn ensure_root_media_collection(pool: &rustango::sql::Pool) -> Result<(), ExecError> {
835 let existing: Vec<crate::media::MediaCollection> =
836 crate::media::MediaCollection::objects().fetch(pool).await?;
837 if !existing.is_empty() {
838 return Ok(());
839 }
840 let mut row = crate::media::MediaCollection {
841 id: Auto::Unset,
842 name: "Root".to_owned(),
843 parent_id: None,
844 sort_order: 0,
845 created_at: Auto::Unset,
846 };
847 row.insert_pool(pool).await?;
848 Ok(())
849}
850
851async fn upsert_page_type(
857 pool: &rustango::sql::Pool,
858 handler: &dyn PageTypeHandler,
859) -> Result<(), ExecError> {
860 let parents_json = serde_json::to_value(handler.allowed_parent_types())
861 .unwrap_or(serde_json::Value::Array(Vec::new()));
862 let children_json = serde_json::to_value(handler.allowed_child_types())
863 .unwrap_or(serde_json::Value::Array(Vec::new()));
864
865 let mut existing: Vec<PageType> = PageType::objects()
866 .where_(PageType::type_name.eq(handler.type_name().to_string()))
867 .fetch(pool)
868 .await?;
869
870 if let Some(mut row) = existing.pop() {
871 row.app_label = handler.app_label().to_owned();
872 row.verbose_name = handler.verbose_name().to_owned();
873 row.default_template = handler.default_template().to_owned();
874 row.view_mode = handler.view_mode().as_str().to_owned();
875 row.is_creatable = handler.is_creatable();
876 row.allowed_parent_types = parents_json;
877 row.allowed_child_types = children_json;
878 row.workflow = handler.workflow_slug().unwrap_or_default().to_owned();
879 row.save_pool(pool).await?;
880 } else {
881 let mut row = PageType {
882 id: Auto::Unset,
883 app_label: handler.app_label().to_owned(),
884 type_name: handler.type_name().to_owned(),
885 verbose_name: handler.verbose_name().to_owned(),
886 default_template: handler.default_template().to_owned(),
887 view_mode: handler.view_mode().as_str().to_owned(),
888 is_creatable: handler.is_creatable(),
889 allowed_parent_types: parents_json,
890 allowed_child_types: children_json,
891 workflow: handler.workflow_slug().unwrap_or_default().to_owned(),
892 created_at: Auto::Unset,
893 updated_at: Auto::Unset,
894 };
895 row.insert_pool(pool).await?;
896 }
897 Ok(())
898}
899
900async fn reconcile_form_notification_targets(
905 pool: &rustango::sql::Pool,
906) -> Result<(), rustango::sql::ExecError> {
907 use rustango::core::Column as _;
908 use rustango::sql::FetcherPool as _;
909 let forms: Vec<crate::snippet::Snippet> = crate::snippet::Snippet::objects()
910 .where_(crate::snippet::Snippet::type_name.eq("form".to_owned()))
911 .fetch(pool)
912 .await?;
913 for f in forms {
914 let id = f.id.get().copied().unwrap_or_default();
915 let parsed = crate::forms::schema::parse_draft(&f.data);
916 crate::notify::targets::sync_form_email(
917 pool,
918 id,
919 &f.title,
920 &parsed.settings.notify_emails,
921 )
922 .await?;
923 }
924 Ok(())
925}
926
927#[cfg(all(test, feature = "sqlite"))]
928mod tests {
929 use super::*;
932 use rustango::core::Model as _;
933 use rustango::sql::Pool;
934 use rustango::tenancy::permissions::{Role, RolePermission};
935
936 async fn mem_pool() -> Pool {
937 let pool = Pool::connect("sqlite::memory:")
938 .await
939 .expect("in-memory sqlite");
940 for schema in [&Role::SCHEMA, &RolePermission::SCHEMA] {
941 let ddl = rustango::migrate::ddl::create_table_if_not_exists_sql_with_dialect(
942 pool.dialect(),
943 schema,
944 );
945 for stmt in ddl.split(';').map(str::trim).filter(|s| !s.is_empty()) {
946 rustango::sql::raw_execute_pool(&pool, stmt, Vec::new())
947 .await
948 .expect("ddl");
949 }
950 }
951 pool
952 }
953
954 #[tokio::test]
965 async fn a_repeated_codename_is_granted_once() {
966 let pool = mem_pool().await;
967
968 seed_role_with_codenames(
969 &pool,
970 "Administrator",
971 "every codename",
972 &[
973 "rpt_connection.view".to_owned(),
974 "cms_page.view".to_owned(),
975 "rpt_connection.view".to_owned(),
977 ],
978 )
979 .await
980 .expect("seeding a role must tolerate a repeated codename");
981
982 let role: Role = Role::objects()
983 .where_(Role::name.eq("Administrator".to_owned()))
984 .first(&pool)
985 .await
986 .expect("query")
987 .expect("the role was created");
988 let role_id = role.id.get().copied().unwrap_or_default();
989
990 let granted: Vec<RolePermission> = RolePermission::objects()
991 .where_(RolePermission::role_id.eq(role_id))
992 .fetch(&pool)
993 .await
994 .expect("query");
995
996 assert_eq!(granted.len(), 2, "one row per distinct codename");
997 let mut codes: Vec<&str> = granted.iter().map(|p| p.codename.as_str()).collect();
998 codes.sort_unstable();
999 assert_eq!(codes, ["cms_page.view", "rpt_connection.view"]);
1000 }
1001}