Skip to main content

capy_cli/resource/
mod.rs

1mod evolve;
2mod field;
3mod frontend;
4pub use evolve::{add_field, add_index};
5
6use crate::{edit::EditPlan, names::GeneratedNames, Generator};
7use anyhow::{bail, Context, Result};
8use field::{Field, Kind};
9use std::path::{Path, PathBuf};
10
11/// Generate application-owned CRUD, explicit contracts, migrations, tests and fixtures.
12/// Existing files are never overwritten. Registry changes commit together or roll back.
13pub fn make_resource(
14    root: &Path,
15    name: &str,
16    definitions: &[String],
17    frontend: bool,
18) -> Result<Vec<PathBuf>> {
19    make_resource_with_options(root, name, definitions, frontend, None, None)
20}
21
22/// Explicit resource authorization shape. Application policies remain editable code.
23#[derive(Clone, Copy, Debug, PartialEq, Eq)]
24pub enum AccessProfile {
25    /// Authenticated owner-scoped reads and authenticated mutations.
26    Private,
27    /// Public list/show; authenticated, owner-controlled mutations.
28    PublicRead,
29}
30
31/// Generate a resource with an explicit access profile.
32/// `None` preserves the historical default: private with auth, public without auth.
33pub fn make_resource_with_access(
34    root: &Path,
35    name: &str,
36    definitions: &[String],
37    frontend: bool,
38    access: Option<AccessProfile>,
39) -> Result<Vec<PathBuf>> {
40    make_resource_with_options(root, name, definitions, frontend, access, None)
41}
42
43/// Generate optional nested list/create/show conventions for one reference target.
44pub fn make_resource_with_options(
45    root: &Path,
46    name: &str,
47    definitions: &[String],
48    frontend: bool,
49    access: Option<AccessProfile>,
50    nested: Option<&str>,
51) -> Result<Vec<PathBuf>> {
52    let names = GeneratedNames::new(name)?;
53    if names.module.len() > 40 {
54        bail!("Resource names must be at most 40 characters after snake_case conversion.");
55    }
56    let mut fields = Field::parse_all(definitions)?;
57    for field in &mut fields {
58        if field.kind == Kind::Enum {
59            field.enum_resource = Some(names.module.clone());
60        }
61    }
62    let mut plan = EditPlan::new(root)?;
63    for field in &mut fields {
64        if let Some(reference) = &mut field.reference {
65            let path = format!("app/models/{}.rs", reference.target);
66            let source = plan.read(&path).with_context(|| {
67                format!(
68                    "Generate the referenced resource {} first; no files changed.",
69                    reference.target
70                )
71            })?;
72            let (kind, has_owner) = reference_model_info(&source).with_context(|| format!(
73                "Cannot use {path} as a reference target; its Model must have an i32, i64 or UUID id. No files changed."
74            ))?;
75            field.kind = kind;
76            reference.has_owner = has_owner;
77            plan.read(&format!("tests/factories/{}.rs", reference.target)).with_context(|| format!(
78                "Generate the referenced resource {} first so its factory is available; no files changed.", reference.target
79            ))?;
80        }
81    }
82    if fields.iter().all(|field| field.reference.is_some()) {
83        bail!("A resource needs at least one non-reference field for its public feature.");
84    }
85    let nested = nested
86        .map(GeneratedNames::new)
87        .transpose()?
88        .map(|names| names.module);
89    if let Some(parent) = &nested {
90        if !fields.iter().any(|field| {
91            field
92                .reference
93                .as_ref()
94                .is_some_and(|reference| &reference.target == parent)
95        }) {
96            bail!("--nested {parent} requires a {parent}_id:references:Parent field; no files changed.");
97        }
98    }
99    let manifest = plan.read("Cargo.toml")?.parse::<toml_edit::DocumentMut>()?;
100    let crate_name = manifest["package"]["name"]
101        .as_str()
102        .context("Missing package.name")?
103        .replace('-', "_");
104    let auth = manifest
105        .get("dependencies")
106        .and_then(|v| v.get("capy"))
107        .and_then(|v| v.get("features"))
108        .and_then(toml_edit::Item::as_array)
109        .is_some_and(|features| features.iter().any(|f| f.as_str() == Some("auth")));
110    if access.is_some() && !auth {
111        bail!("--access private/public-read requires authentication; run capy make:auth first.");
112    }
113    if auth && fields.iter().any(|f| f.name == "owner_id") {
114        bail!(
115            "owner_id is generated from the authenticated identity; it cannot be an input field."
116        );
117    }
118    if auth
119        && fields.iter().any(|field| {
120            field
121                .reference
122                .as_ref()
123                .is_some_and(|reference| reference.target == "user")
124        })
125    {
126        bail!("Authenticated resources already belong to User through generated owner_id; use that relation for the author/owner. No files changed.");
127    }
128    let resource = Resource {
129        names,
130        fields,
131        auth,
132        public_read: access == Some(AccessProfile::PublicRead),
133        nested,
134        crate_name,
135    };
136    resource.backend(&mut plan)?;
137    if frontend {
138        resource.frontend(root, &mut plan)?;
139    }
140    plan.commit()
141}
142
143struct Resource {
144    names: GeneratedNames,
145    fields: Vec<Field>,
146    auth: bool,
147    public_read: bool,
148    nested: Option<String>,
149    crate_name: String,
150}
151
152fn reference_model_info(source: &str) -> Result<(Kind, bool)> {
153    let model = syn::parse_file(source)?
154        .items
155        .into_iter()
156        .find_map(|item| match item {
157            syn::Item::Struct(item) if item.ident == "Model" => Some(item),
158            _ => None,
159        })
160        .context("Missing Model struct")?;
161    let (id, has_owner) = match model.fields {
162        syn::Fields::Named(fields) => {
163            let has_owner = fields.named.iter().any(|field| {
164                field
165                    .ident
166                    .as_ref()
167                    .is_some_and(|ident| ident == "owner_id")
168            });
169            (
170                fields
171                    .named
172                    .into_iter()
173                    .find(|field| field.ident.as_ref().is_some_and(|ident| ident == "id"))
174                    .context("Missing Model.id")?,
175                has_owner,
176            )
177        }
178        _ => anyhow::bail!("Model needs named fields"),
179    };
180    let syn::Type::Path(path) = id.ty else {
181        anyhow::bail!("Unsupported Model.id type")
182    };
183    match path
184        .path
185        .segments
186        .last()
187        .map(|segment| segment.ident.to_string())
188        .as_deref()
189    {
190        Some("i32") => Ok((Kind::Integer, has_owner)),
191        Some("i64") => Ok((Kind::Bigint, has_owner)),
192        Some("Uuid") => Ok((Kind::Uuid, has_owner)),
193        _ => anyhow::bail!("Unsupported Model.id type"),
194    }
195}
196
197impl Resource {
198    fn table(&self) -> String {
199        plural_table(&self.names.module)
200    }
201
202    fn render(&self, template: &str) -> String {
203        use heck::ToUpperCamelCase;
204        template
205            .replace("{{plural-type}}", &self.table().to_upper_camel_case())
206            .replace("{{module}}", &self.names.module)
207            .replace("{{type}}", &self.names.ty)
208            .replace("{{table}}", &self.table())
209            .replace("{{crate}}", &self.crate_name)
210    }
211}
212
213fn plural_table(name: &str) -> String {
214    if name.ends_with('y')
215        && !["ay", "ey", "iy", "oy", "uy"]
216            .iter()
217            .any(|suffix| name.ends_with(suffix))
218    {
219        format!("{}ies", &name[..name.len() - 1])
220    } else if name.ends_with(['s', 'x', 'z']) || name.ends_with("ch") || name.ends_with("sh") {
221        format!("{name}es")
222    } else {
223        format!("{name}s")
224    }
225}
226
227impl Resource {
228    fn enum_definitions(&self) -> String {
229        use heck::ToUpperCamelCase;
230        self.fields.iter().filter_map(|field| field.enum_values.as_ref().map(|values| {
231            let ty = format!("{}{}", self.names.ty, field.name.to_upper_camel_case());
232            let variants = values.iter().map(|value| format!("#[sea_orm(string_value = {value:?})] {} ,", value.to_upper_camel_case())).collect::<Vec<_>>().join("\n");
233            format!("#[derive(Clone, Debug, PartialEq, Eq, EnumIter, DeriveActiveEnum, capy::serde::Serialize, capy::serde::Deserialize, capy::ApiSchema)]\n#[sea_orm(rs_type = \"String\", db_type = \"String(StringLen::N(255))\")]\n#[serde(crate = \"capy::serde\", rename_all = \"snake_case\")]\n#[schemars(crate = \"capy::schema\", rename_all = \"snake_case\")]\npub enum {ty} {{ {variants} }}")
234        })).collect::<Vec<_>>().join("\n")
235    }
236
237    fn backend(&self, plan: &mut EditPlan<'_>) -> Result<()> {
238        let module = &self.names.module;
239        let ty = &self.names.ty;
240        let table = self.table();
241        let factory = plan.read("src/bootstrap.rs").context("Resource tests require the shared application() factory. See the 0.9 upgrade guide; no files changed")?;
242        if !factory.contains("pub fn application()") {
243            bail!("Expose the shared application() factory before generating resource tests; no files changed.");
244        }
245        register(
246            plan,
247            "app/models/mod.rs",
248            module,
249            &format!("pub use {module}::Entity as {ty};\npub use {module}::Model as {ty}Model;"),
250            Generator::Model,
251            &self.names,
252        )?;
253        let model_fields = self
254            .fields
255            .iter()
256            .map(|f| format!("pub {}: {},", f.name, f.entity_type()))
257            .collect::<Vec<_>>()
258            .join("\n");
259        let relation_variants = self.relation_variants();
260        let related_impls = self.related_impls();
261        let enums = self.enum_definitions();
262        plan.create(&format!("app/models/{module}.rs"), format!(
263            "//! Persistence model; use the response DTO at the HTTP boundary.\nuse capy::sea_orm::{{self, entity::prelude::*}};\n{enums}\n#[derive(Clone, Debug, PartialEq, DeriveEntityModel)]\n#[sea_orm(table_name = {table:?})]\npub struct Model {{ #[sea_orm(primary_key)] pub id: i32, {} {model_fields} }}\n#[derive(Copy, Clone, Debug, EnumIter, DeriveRelation)]\npub enum Relation {{ {relation_variants} }}\n{related_impls}\nimpl ActiveModelBehavior for ActiveModel {{}}\n",
264            if self.auth { "pub owner_id: i64," } else { "" }))?;
265        let reverse_relations = self.reverse_relations();
266        if !reverse_relations.is_empty() {
267            let name = format!("{module}_relations");
268            register(
269                plan,
270                "app/models/mod.rs",
271                &name,
272                "",
273                Generator::Model,
274                &GeneratedNames::new(&name)?,
275            )?;
276            plan.create(
277                &format!("app/models/{name}.rs"),
278                format!("//! Reverse relations live outside existing application-owned models.\nuse capy::sea_orm::entity::prelude::*;\n{reverse_relations}"),
279            )?;
280        }
281        ensure_group(plan, "responses")?;
282        register(
283            plan,
284            "app/responses/mod.rs",
285            module,
286            "",
287            Generator::Controller,
288            &self.names,
289        )?;
290        let response_fields = self
291            .fields
292            .iter()
293            .map(|f| {
294                if f.kind == Kind::Decimal {
295                    format!(
296                        "#[schemars(extend(\"pattern\" = r\"{}\"))] pub {}: {},",
297                        f.decimal_pattern(),
298                        f.name,
299                        f.wire_type()
300                    )
301                } else {
302                    format!("pub {}: {},", f.name, f.wire_type())
303                }
304            })
305            .collect::<Vec<_>>()
306            .join("\n");
307        let conversions = self
308            .fields
309            .iter()
310            .map(|f| {
311                let name = &f.name;
312                let value = if f.kind == Kind::Bigint {
313                    if f.nullable {
314                        format!("row.{name}.map(|value| value.to_string())")
315                    } else {
316                        format!("row.{name}.to_string()")
317                    }
318                } else {
319                    format!("row.{name}")
320                };
321                format!("{name}: {value},")
322            })
323            .collect::<Vec<_>>()
324            .join("\n");
325        plan.create(&format!("app/responses/{module}.rs"), format!("use capy::prelude::*;\n#[derive(Serialize, ApiSchema)]\n#[serde(crate = \"capy::serde\")]\n#[schemars(crate = \"capy::schema\")]\npub struct {ty}Response {{ pub id: i32, {response_fields} }}\nimpl From<crate::app::models::{module}::Model> for {ty}Response {{ fn from(row: crate::app::models::{module}::Model) -> Self {{ Self {{ id: row.id, {conversions} }} }} }}"))?;
326        for action in ["create", "update"] {
327            let request_module = format!("{action}_{module}");
328            register(
329                plan,
330                "app/requests/mod.rs",
331                &request_module,
332                "",
333                Generator::Request,
334                &GeneratedNames::new(&request_module)?,
335            )?;
336            plan.create(
337                &format!("app/requests/{request_module}.rs"),
338                self.request(action == "create"),
339            )?;
340        }
341        register(
342            plan,
343            "app/controllers/mod.rs",
344            &format!("{module}_controller"),
345            "",
346            Generator::Controller,
347            &self.names,
348        )?;
349        plan.create(
350            &format!("app/controllers/{module}_controller.rs"),
351            self.controller(),
352        )?;
353        if self.auth {
354            ensure_group(plan, "policies")?;
355            register(
356                plan,
357                "app/policies/mod.rs",
358                &format!("{module}_policy"),
359                "",
360                Generator::Controller,
361                &self.names,
362            )?;
363            plan.create(
364                &format!("app/policies/{module}_policy.rs"),
365                self.render(include_str!("../../templates/resource/policy.rs.txt")),
366            )?;
367        }
368        register(
369            plan,
370            "routes/mod.rs",
371            &table,
372            "",
373            Generator::Controller,
374            &GeneratedNames::new(&table)?,
375        )?;
376        plan.create(
377            &format!("routes/{table}.rs"),
378            self.render(include_str!("../../templates/resource/routes.rs.txt"))
379                .replace(
380                    "{{read-contract}}",
381                    if self.auth && !self.public_read {
382                        ".authenticated().error(403)"
383                    } else {
384                        ""
385                    },
386                )
387                .replace(
388                    "{{write-contract}}",
389                    if self.auth {
390                        ".authenticated().error(403)"
391                    } else {
392                        ""
393                    },
394                )
395                .replace("{{nested-routes}}", &self.nested_routes()),
396        )?;
397        plan.anchor(
398            "routes/api.rs",
399            "// capy:routes",
400            &format!(".merge(crate::routes::{table}::routes())"),
401        )?;
402        // Ordering is the explicit registry's order, not a wall-clock filename.
403        let migration = format!("m_resource_{module}");
404        self.names.check_registry(
405            &plan.read("database/migrations/mod.rs")?,
406            &migration,
407            Generator::Migration,
408        )?;
409        plan.create(
410            &format!("database/migrations/{migration}.rs"),
411            self.migration(),
412        )?;
413        plan.anchor(
414            "database/migrations/mod.rs",
415            "// capy:modules",
416            &format!("mod {migration};"),
417        )?;
418        plan.anchor(
419            "database/migrations/mod.rs",
420            "// capy:migrations",
421            &format!("Box::new({migration}::Migration),"),
422        )?;
423        plan.create(&format!("database/seeds/{table}.rs"), self.seed())?;
424        plan.anchor(
425            "database/seeds.rs",
426            "// capy:seed-modules",
427            &format!("mod {table};"),
428        )?;
429        plan.anchor(
430            "database/seeds.rs",
431            "// capy:seeds",
432            &format!("{table}::run(&ctx).await?;"),
433        )?;
434        plan.create(&format!("tests/factories/{module}.rs"), self.factory())?;
435        plan.create(&format!("tests/{table}.rs"), self.tests())?;
436        Ok(())
437    }
438
439    fn relation_variants(&self) -> String {
440        use heck::ToUpperCamelCase;
441        let mut variants = Vec::new();
442        if self.auth {
443            variants.push("#[sea_orm(belongs_to = \"super::user::Entity\", from = \"Column::OwnerId\", to = \"super::user::Column::Id\", on_delete = \"Cascade\")] Owner,".to_owned());
444        }
445        for field in &self.fields {
446            if let Some(reference) = &field.reference {
447                let target = &reference.target;
448                let column = field.name.to_upper_camel_case();
449                let variant = target.to_upper_camel_case();
450                let delete = reference.on_delete.sea_orm();
451                variants.push(format!("#[sea_orm(belongs_to = \"super::{target}::Entity\", from = \"Column::{column}\", to = \"super::{target}::Column::Id\", on_delete = \"{delete}\")] {variant},"));
452            }
453        }
454        variants.join("\n")
455    }
456
457    fn nested_field(&self) -> Option<&Field> {
458        let parent = self.nested.as_ref()?;
459        self.fields.iter().find(|field| {
460            field
461                .reference
462                .as_ref()
463                .is_some_and(|reference| &reference.target == parent)
464        })
465    }
466
467    fn nested_routes(&self) -> String {
468        use heck::ToUpperCamelCase;
469        let Some(field) = self.nested_field() else {
470            return String::new();
471        };
472        let parent = self.nested.as_ref().expect("validated nested target");
473        let path = format!(
474            "/{}/{{{}}}/{}",
475            plural_table(parent),
476            field.name,
477            self.table()
478        );
479        let show_path = format!("{path}/{{id}}");
480        let parent_type = parent.to_upper_camel_case();
481        let child_type = &self.names.ty;
482        let plural_type = self.table().to_upper_camel_case();
483        let key_type = field
484            .entity_type()
485            .trim_start_matches("Option<")
486            .trim_end_matches('>')
487            .to_owned();
488        let read_contract = if self.auth && !self.public_read {
489            ".authenticated().error(403)"
490        } else {
491            ""
492        };
493        let write_contract = if self.auth {
494            ".authenticated().error(403)"
495        } else {
496            ""
497        };
498        format!(".get({path:?}, controller::index_nested).operation(\"list{plural_type}For{parent_type}\").path::<{key_type}>({:?}).query::<Pagination>().response::<Page<{child_type}Response>>().error(404){read_contract}\n.post({path:?}, controller::create_nested).operation(\"create{child_type}For{parent_type}\").path::<{key_type}>({:?}).body::<Create{child_type}Request>().created::<{child_type}Response>().error(404).error(409){write_contract}\n.get({show_path:?}, controller::show_nested).operation(\"show{child_type}For{parent_type}\").path::<{key_type}>({:?}).path::<i32>(\"id\").response::<{child_type}Response>().error(404){read_contract}", field.name, field.name, field.name)
499    }
500
501    fn related_impls(&self) -> String {
502        use heck::ToUpperCamelCase;
503        let mut relations = Vec::new();
504        if self.auth {
505            relations.push("impl Related<super::user::Entity> for Entity { fn to() -> RelationDef { Relation::Owner.def() } }".to_owned());
506        }
507        for field in &self.fields {
508            if let Some(reference) = &field.reference {
509                let target = &reference.target;
510                let variant = target.to_upper_camel_case();
511                relations.push(format!("impl Related<super::{target}::Entity> for Entity {{ fn to() -> RelationDef {{ Relation::{variant}.def() }} }}"));
512            }
513        }
514        relations.join("\n")
515    }
516
517    fn reverse_relations(&self) -> String {
518        use heck::ToUpperCamelCase;
519        let child = &self.names.module;
520        let mut relations = Vec::new();
521        if self.auth {
522            relations.push(format!("impl Related<super::{child}::Entity> for super::user::Entity {{ fn to() -> RelationDef {{ super::{child}::Relation::Owner.def().rev() }} }}"));
523        }
524        for field in &self.fields {
525            if let Some(reference) = &field.reference {
526                let target = &reference.target;
527                let variant = target.to_upper_camel_case();
528                relations.push(format!("impl Related<super::{child}::Entity> for super::{target}::Entity {{ fn to() -> RelationDef {{ super::{child}::Relation::{variant}.def().rev() }} }}"));
529            }
530        }
531        relations.join("\n")
532    }
533
534    fn request(&self, create: bool) -> String {
535        let name = format!(
536            "{}{}Request",
537            if create { "Create" } else { "Update" },
538            self.names.ty
539        );
540        let mut defaults = String::new();
541        let mut fields = String::new();
542        for field in &self.fields {
543            let n = &field.name;
544            if create {
545                if let Some(value) = &field.default {
546                    fields.push_str(&format!("#[serde(default = \"default_{n}\")]\n"));
547                    defaults.push_str(&format!(
548                        "fn default_{n}() -> {} {{ {} }}\n",
549                        field.wire_type(),
550                        field.literal(value, true)
551                    ));
552                }
553            }
554            if matches!(field.kind, Kind::String | Kind::Text) {
555                fields.push_str(&format!(
556                    "#[validate(length(min = 1, max = {}))]\n",
557                    if field.kind == Kind::String {
558                        255
559                    } else {
560                        50_000
561                    }
562                ));
563            } else if field.kind == Kind::Bigint {
564                fields.push_str("#[validate(custom(function = \"valid_bigint\"))]\n");
565            } else if field.kind == Kind::Decimal {
566                fields.push_str(&format!("#[validate(custom(function = \"valid_{n}\"))]\n#[schemars(extend(\"pattern\" = r\"{}\"))]\n", field.decimal_pattern()));
567                let (precision, scale) = field.decimal.expect("parsed decimal");
568                let integer = precision - scale;
569                defaults.push_str(&format!("fn valid_{n}(value: &str) -> std::result::Result<(), capy::validator::ValidationError> {{ let unsigned = value.strip_prefix('-').unwrap_or(value); let (whole, fraction) = unsigned.split_once('.').unwrap_or((unsigned, \"\")); let integer_digits = if whole == \"0\" {{ 0 }} else {{ whole.len() }}; let valid = !whole.is_empty() && whole.bytes().all(|digit| digit.is_ascii_digit()) && (whole == \"0\" || !whole.starts_with('0')) && integer_digits <= {integer} && fraction.len() <= {scale} && fraction.bytes().all(|digit| digit.is_ascii_digit()) && (!unsigned.contains('.') || !fraction.is_empty()); if valid {{ Ok(()) }} else {{ Err(capy::validator::ValidationError::new(\"decimal\")) }} }}\n"));
570            }
571            fields.push_str(&format!("pub {n}: {},\n", field.wire_type()));
572        }
573        if self.fields.iter().any(|f| f.kind == Kind::Bigint) {
574            defaults.push_str("fn valid_bigint(value: &str) -> std::result::Result<(), capy::validator::ValidationError> { value.parse::<i64>().map(|_| ()).map_err(|_| capy::validator::ValidationError::new(\"bigint\")) }\n");
575        }
576        format!("use capy::prelude::*;\n/// Deliberate public input; unknown fields are rejected.\n#[derive(Serialize, Deserialize, Validate, ApiSchema)]\n#[serde(crate = \"capy::serde\", deny_unknown_fields)]\n#[validate(crate = \"capy::validator\")]\n#[schemars(crate = \"capy::schema\")]\npub struct {name} {{ {fields} }}\n{defaults}")
577    }
578
579    fn input_value(field: &Field) -> String {
580        let n = &field.name;
581        if field.kind == Kind::Bigint {
582            let expr = if field.nullable {
583                format!("input.{n}.map(|value| value.parse::<i64>()).transpose()")
584            } else {
585                format!("input.{n}.parse::<i64>()")
586            };
587            format!("{expr}.map_err(|_| AppError::Validation([({n:?}.into(), vec![\"Must be an integer within i64 bounds.\".into()])].into()))?")
588        } else {
589            format!("input.{n}")
590        }
591    }
592
593    fn controller(&self) -> String {
594        let mut source = self.render(include_str!("../../templates/resource/controller.rs.txt"));
595        let module = &self.names.module;
596        let ty = &self.names.ty;
597        let needs_filter = self.nested.is_some() || (self.auth && !self.public_read);
598        source = source.replace("{{auth-imports}}", &format!("{}{}", if self.auth {format!("use capy::auth::{{AuthUser, Policy}};\nuse crate::app::policies::{module}_policy::{{{ty}Policy, {ty}Action}};\n")} else {String::new()}, if needs_filter {"use capy::sea_orm::{ColumnTrait, QueryFilter};\n"} else {""}))
599            .replace("{{read-auth-param}}", if self.auth && !self.public_read {"AuthUser(user): AuthUser, "} else {""})
600            .replace("{{write-auth-param}}", if self.auth {"AuthUser(user): AuthUser, "} else {""})
601            .replace("{{owner-filter}}", &if self.auth && !self.public_read {format!(".filter({module}::Column::OwnerId.eq(user.id))")} else {String::new()})
602            .replace("{{owner-value}}", if self.auth {"owner_id: Set(user.id),"} else {""});
603        for (action, resource) in [
604            ("list", "None"),
605            ("create", "None"),
606            ("read", "Some(&row)"),
607            ("update", "Some(&row)"),
608            ("delete", "Some(&row)"),
609        ] {
610            use heck::ToUpperCamelCase;
611            source = source.replace(
612                &format!("{{{{authorize-{action}}}}}"),
613                &if self.auth && !(self.public_read && matches!(action, "list" | "read")) {
614                    format!(
615                        "{ty}Policy::authorize(&user, {ty}Action::{}, &{resource})?;",
616                        action.to_upper_camel_case()
617                    )
618                } else {
619                    String::new()
620                },
621            );
622        }
623        let reference_checks = self.fields.iter().filter_map(|field| field.reference.as_ref().map(|reference| {
624            let name = &field.name;
625            let target = &reference.target;
626            let value = if field.kind == Kind::Bigint {
627                if field.nullable {
628                    format!("input.{name}.as_ref().map(|id| id.parse::<i64>()).transpose().map_err(|_| AppError::Validation([({name:?}.into(), vec![\"Must be an integer within i64 bounds.\".into()])].into()))?")
629                } else {
630                    format!("Some(input.{name}.parse::<i64>().map_err(|_| AppError::Validation([({name:?}.into(), vec![\"Must be an integer within i64 bounds.\".into()])].into()))?)")
631                }
632            } else if field.nullable {
633                format!("input.{name}")
634            } else {
635                format!("Some(input.{name})")
636            };
637            format!("if let Some(reference_id) = {value} {{ if crate::app::models::{target}::Entity::find_by_id(reference_id).one(&ctx.db).await?.is_none() {{ return Err(AppError::Validation([({name:?}.into(), vec![\"Referenced record does not exist.\".into()])].into())); }} }}")
638        })).collect::<Vec<_>>().join("\n");
639        let source = source
640            .replace("{{create-reference-checks}}", &reference_checks)
641            .replace("{{update-reference-checks}}", &reference_checks)
642            .replace(
643                "{{create-values}}",
644                &self
645                    .fields
646                    .iter()
647                    .map(|f| format!("{}: Set({}),", f.name, Self::input_value(f)))
648                    .collect::<Vec<_>>()
649                    .join("\n"),
650            )
651            .replace(
652                "{{update-values}}",
653                &self
654                    .fields
655                    .iter()
656                    .map(|f| format!("row.{} = Set({});", f.name, Self::input_value(f)))
657                    .collect::<Vec<_>>()
658                    .join("\n"),
659            );
660        format!("{source}\n{}", self.nested_controller())
661    }
662
663    fn nested_controller(&self) -> String {
664        use heck::ToUpperCamelCase;
665        let Some(field) = self.nested_field() else {
666            return String::new();
667        };
668        let parent = self.nested.as_ref().expect("validated nested target");
669        let parent_type = match field.kind {
670            Kind::Integer => "i32",
671            Kind::Bigint => "i64",
672            Kind::Uuid => "capy::uuid::Uuid",
673            _ => unreachable!("validated reference key kind"),
674        };
675        let parent_mismatch = match (field.kind, field.nullable) {
676            (Kind::Bigint, true) => format!(
677                "input.{}.as_deref().and_then(|id| id.parse::<i64>().ok()) != Some(parent_id)",
678                field.name
679            ),
680            (Kind::Bigint, false) => format!(
681                "input.{}.parse::<i64>().ok() != Some(parent_id)",
682                field.name
683            ),
684            (_, true) => format!("input.{} != Some(parent_id)", field.name),
685            (_, false) => format!("input.{} != parent_id", field.name),
686        };
687        let read_auth = if self.auth && !self.public_read {
688            "AuthUser(user): AuthUser, "
689        } else {
690            ""
691        };
692        let write_auth = if self.auth {
693            "AuthUser(user): AuthUser, "
694        } else {
695            ""
696        };
697        let list_policy = if self.auth && !self.public_read {
698            format!(
699                "{}Policy::authorize(&user, {}Action::List, &None)?;",
700                self.names.ty, self.names.ty
701            )
702        } else {
703            String::new()
704        };
705        let read_policy = if self.auth && !self.public_read {
706            format!(
707                "{}Policy::authorize(&user, {}Action::Read, &Some(&row))?;",
708                self.names.ty, self.names.ty
709            )
710        } else {
711            String::new()
712        };
713        let owner_filter = if self.auth && !self.public_read {
714            format!(
715                ".filter({}::Column::OwnerId.eq(user.id))",
716                self.names.module
717            )
718        } else {
719            String::new()
720        };
721        let create_call = if self.auth {
722            "create(AuthUser(user), Context(ctx), Validated(input)).await"
723        } else {
724            "create(Context(ctx), Validated(input)).await"
725        };
726        self.render(include_str!(
727            "../../templates/resource/nested-controller.rs.txt"
728        ))
729        .replace("{{nested-read-auth}}", read_auth)
730        .replace("{{nested-write-auth}}", write_auth)
731        .replace("{{parent-module}}", parent)
732        .replace("{{parent-type}}", parent_type)
733        .replace("{{parent-column}}", &field.name.to_upper_camel_case())
734        .replace("{{parent-mismatch}}", &parent_mismatch)
735        .replace("{{nested-authorize-list}}", &list_policy)
736        .replace("{{nested-authorize-read}}", &read_policy)
737        .replace("{{nested-owner-filter}}", &owner_filter)
738        .replace("{{create-call}}", create_call)
739    }
740
741    fn migration(&self) -> String {
742        let table = self.table();
743        let mut columns = String::new();
744        let mut indexes = String::new();
745        let mut checks = String::new();
746        for (i, field) in self.fields.iter().enumerate() {
747            let ty = match field.kind {
748                Kind::String => "string_len(255)",
749                Kind::Text => "text()",
750                Kind::Boolean => "boolean()",
751                Kind::Integer => "integer()",
752                Kind::Bigint => "big_integer()",
753                Kind::Float => "double()",
754                Kind::Uuid => "uuid()",
755                Kind::Datetime => "timestamp_with_time_zone()",
756                Kind::Date => "date()",
757                Kind::Enum => "string_len(255)",
758                Kind::Decimal => "string_len(41)",
759            };
760            let mut column = format!(".col(ColumnDef::new(Alias::new({:?})).{ty}", field.name);
761            if !field.nullable {
762                column.push_str(".not_null()");
763            }
764            if let Some(default) = &field.default {
765                let value = if field.kind == Kind::Enum {
766                    format!("{default:?}")
767                } else if field.kind == Kind::Uuid {
768                    let bytes = if field.nullable {
769                        "value.map(|id| id.as_bytes().to_vec())"
770                    } else {
771                        "value.as_bytes().to_vec()"
772                    };
773                    format!("if manager.get_database_backend() == capy::sea_orm::DbBackend::Sqlite {{ Expr::value({bytes}) }} else {{ Expr::value(value) }}")
774                } else {
775                    "value".into()
776                };
777                if field.kind == Kind::Enum {
778                    column.push_str(&format!(".default({value})"));
779                } else {
780                    column.push_str(&format!(
781                        ".default({{let value: {} = {}; {value}}})",
782                        field.entity_type(),
783                        field.literal(default, false)
784                    ));
785                }
786            }
787            column.push_str(")\n");
788            columns.push_str(&column);
789            if let Some(values) = &field.enum_values {
790                let allowed = values
791                    .iter()
792                    .map(|value| format!("{value:?}"))
793                    .collect::<Vec<_>>()
794                    .join(", ");
795                checks.push_str(&format!(
796                    ".check(Expr::col(Alias::new({:?})).is_in([{allowed}]))\n",
797                    field.name
798                ));
799            }
800            if let Some(reference) = &field.reference {
801                let target_table = plural_table(&reference.target);
802                let delete = reference.on_delete.sea_orm();
803                columns.push_str(&format!(".foreign_key(ForeignKey::create().name({:?}).from_col(Alias::new({:?})).to(Alias::new({target_table:?}), Alias::new(\"id\")).on_delete(ForeignKeyAction::{delete}))\n", format!("fk_{table}_{i}"), field.name));
804            }
805            if field.unique || field.index {
806                indexes.push_str(&format!("manager.create_index(Index::create().name({:?}).table(Alias::new({table:?})).col(Alias::new({:?})){}.to_owned()).await?;\n", format!("idx_{table}_{i}"), field.name, if field.unique {".unique()"} else {""}));
807            }
808        }
809        if self.auth {
810            columns.push_str(".col(ColumnDef::new(Alias::new(\"owner_id\")).big_integer().not_null())\n.foreign_key(ForeignKey::create().from_col(Alias::new(\"owner_id\")).to(Alias::new(\"users\"), Alias::new(\"id\")).on_delete(ForeignKeyAction::Cascade))\n");
811            indexes.push_str(&format!("manager.create_index(Index::create().name({:?}).table(Alias::new({table:?})).col(Alias::new(\"owner_id\")).to_owned()).await?;", format!("idx_{table}_owner")));
812        }
813        format!("use capy::migration::{{self as sea_orm_migration, prelude::*}};\n#[derive(DeriveMigrationName)]\npub struct Migration;\n#[async_trait::async_trait]\nimpl MigrationTrait for Migration {{\nasync fn up(&self, manager: &SchemaManager) -> Result<(), DbErr> {{\nmanager.create_table(Table::create().table(Alias::new({table:?})).col(ColumnDef::new(Alias::new(\"id\")).integer().not_null().auto_increment().primary_key()){columns}{checks}.to_owned()).await?;\n{indexes}\nOk(()) }}\nasync fn down(&self, manager: &SchemaManager) -> Result<(), DbErr> {{ manager.drop_table(Table::drop().table(Alias::new({table:?})).to_owned()).await }} }}")
814    }
815
816    fn values(&self, wire: bool) -> String {
817        self.fields
818            .iter()
819            .map(|f| format!("{}: {},", f.name, f.literal(f.sample(), wire)))
820            .collect::<Vec<_>>()
821            .join("\n")
822    }
823
824    fn seed(&self) -> String {
825        let module = &self.names.module;
826        let owner = if self.auth {
827            "let owner = crate::app::models::user::Entity::find().filter(crate::app::models::user::Column::Email.eq(\"demo@example.test\")).one(ctx.transaction).await?;\nlet Some(owner) = owner else { return Ok(()); };\n"
828        } else {
829            ""
830        };
831        let reference_setup = self.fields.iter().filter_map(|field| field.reference.as_ref().map(|reference| {
832            let target = &reference.target;
833            format!("let Some(reference_{target}) = crate::app::models::{target}::Entity::find().one(ctx.transaction).await? else {{ return Ok(()); }};")
834        })).collect::<Vec<_>>().join("\n");
835        let values = self
836            .fields
837            .iter()
838            .map(|f| {
839                if let Some(reference) = &f.reference {
840                    let value = format!("reference_{}.id", reference.target);
841                    format!(
842                        "{}: Set({}),",
843                        f.name,
844                        if f.nullable {
845                            format!("Some({value})")
846                        } else {
847                            value
848                        }
849                    )
850                } else {
851                    format!("{}: Set({}),", f.name, f.literal(f.sample(), false))
852                }
853            })
854            .collect::<Vec<_>>()
855            .join("\n");
856        format!("//! Insert one development record only when the table is empty; never replace user data.\nuse capy::{{prelude::*, SeedContext, sea_orm::{{ActiveModelTrait, EntityTrait, PaginatorTrait, Set{}}}}};\nuse crate::app::models::{module};\npub async fn run(ctx: &SeedContext<'_>) -> Result<()> {{\nif {module}::Entity::find().count(ctx.transaction).await? != 0 {{ return Ok(()); }}\n{owner}\n{reference_setup}\n{module}::ActiveModel {{ {} {values} ..Default::default() }}.insert(ctx.transaction).await?;\nOk(()) }}", if self.auth {", ColumnTrait, QueryFilter"} else {""}, if self.auth {"owner_id: Set(owner.id),"} else {""})
857    }
858
859    fn factory(&self) -> String {
860        let module = &self.names.module;
861        let ty = &self.names.ty;
862        let fields = self
863            .fields
864            .iter()
865            .map(|f| format!("pub {}: {},", f.name, f.entity_type()))
866            .collect::<Vec<_>>()
867            .join("\n");
868        let values = self
869            .fields
870            .iter()
871            .map(|f| format!("{}: Set(self.{}),", f.name, f.name))
872            .collect::<Vec<_>>()
873            .join("\n");
874        format!("//! Application-owned defaults. Override unique fields for additional records.\nuse {}::app::models::{module};\nuse capy::{{prelude::*, testing::Factory, sea_orm::{{ActiveModelTrait, ConnectionTrait, Set}}}};\npub struct {ty}Factory {{ {} {fields} }}\nimpl Default for {ty}Factory {{ fn default() -> Self {{ Self {{ {} {} }} }} }}\nimpl Factory for {ty}Factory {{ type Model = {module}::Model;\nasync fn create<C: ConnectionTrait>(self, connection: &C) -> Result<Self::Model> {{ Ok({module}::ActiveModel {{ {} {values} ..Default::default() }}.insert(connection).await?) }} }}", self.crate_name, if self.auth {"pub owner_id: i64,"} else {""}, if self.auth {"owner_id: 0,"} else {""}, self.values(false), if self.auth {"owner_id: Set(self.owner_id),"} else {""}).replace("crate::app::models::", &format!("{}::app::models::", self.crate_name))
875    }
876
877    fn tests(&self) -> String {
878        let ty = &self.names.ty;
879        let field = self
880            .fields
881            .iter()
882            .find(|field| field.reference.is_none())
883            .expect("validated non-reference field");
884        let changed = match field.kind {
885            Kind::String | Kind::Text => {
886                if field.sample() == "Updated" {
887                    "Changed again"
888                } else {
889                    "Updated"
890                }
891            }
892            Kind::Boolean => {
893                if field.sample() == "true" {
894                    "false"
895                } else {
896                    "true"
897                }
898            }
899            Kind::Integer | Kind::Bigint | Kind::Float => {
900                if field.sample() == "2" {
901                    "3"
902                } else {
903                    "2"
904                }
905            }
906            Kind::Uuid => "00000000-0000-4000-8000-000000000002",
907            Kind::Datetime => "2026-02-01T00:00:00+00:00",
908            Kind::Date => "2026-02-01",
909            Kind::Enum => field
910                .enum_values
911                .as_ref()
912                .expect("parsed enum")
913                .iter()
914                .find(|value| value.as_str() != field.sample())
915                .expect("at least two enum variants"),
916            Kind::Decimal => {
917                let (precision, scale) = field.decimal.expect("parsed decimal");
918                if scale == 0 {
919                    "2"
920                } else if precision == scale {
921                    "0.2"
922                } else if scale == 1 {
923                    "1.3"
924                } else {
925                    "1.26"
926                }
927            }
928        };
929        let relation_imports = self
930            .fields
931            .iter()
932            .filter_map(|field| {
933                field.reference.as_ref().map(|reference| {
934                    let target = &reference.target;
935                    format!("#[path = \"factories/{target}.rs\"] mod {target}_fixture;")
936                })
937            })
938            .collect::<Vec<_>>()
939            .join("\n");
940        let relation_setup = self.test_relation_setup();
941        let relation_input = self
942            .fields
943            .iter()
944            .filter_map(|field| {
945                field.reference.as_ref().map(|reference| {
946                    let name = &field.name;
947                    let parent = format!("parent_{}", reference.target);
948                    let value = if field.kind == Kind::Bigint {
949                        format!("{parent}.id.to_string()")
950                    } else {
951                        format!("{parent}.id")
952                    };
953                    format!("input[{name:?}] = json!({value});")
954                })
955            })
956            .collect::<Vec<_>>()
957            .join("\n");
958        let relation_assertions = if relation_input.is_empty() {
959            String::new()
960        } else {
961            let child = &self.names.module;
962            let mut assertions = vec![format!("let child_model = application::app::models::{child}::Entity::find_by_id(i32::try_from(row[\"id\"].as_i64().unwrap()).unwrap()).one(app.db()).await?.unwrap();")];
963            for field in &self.fields {
964                if let Some(reference) = &field.reference {
965                    let target = &reference.target;
966                    assertions.push(format!("let related_{target} = child_model.find_related(application::app::models::{target}::Entity).one(app.db()).await?.unwrap(); assert_eq!(related_{target}.id, parent_{target}.id);"));
967                    assertions.push(format!("let related_children = parent_{target}.find_related(application::app::models::{child}::Entity).all(app.db()).await?; assert_eq!(related_children.len(), 1);"));
968                }
969            }
970            assertions.join("\n")
971        };
972        let invalid_reference = self.fields.iter().find(|field| field.reference.is_some()).map(|field| {
973            let invalid = match field.kind {
974                Kind::Integer => "json!(i32::MAX)",
975                Kind::Bigint => "json!(i64::MAX.to_string())",
976                Kind::Uuid => "json!(\"00000000-0000-4000-8000-000000000099\")",
977                _ => unreachable!("validated reference key kind"),
978            };
979            format!("let mut invalid_reference = input.clone(); invalid_reference[{:?}] = {invalid}; session.post(\"/api/{}\").json(&invalid_reference).send().await?.assert_status(StatusCode::UNPROCESSABLE_ENTITY);", field.name, self.table())
980        }).unwrap_or_default();
981        let mut fixture_overrides = Vec::new();
982        if self.auth {
983            fixture_overrides.push("factory.owner_id = owner_id;".to_owned());
984        }
985        for field in &self.fields {
986            if let Some(reference) = &field.reference {
987                let value = format!("parent_{}.id", reference.target);
988                fixture_overrides.push(format!(
989                    "factory.{} = {};",
990                    field.name,
991                    if field.nullable {
992                        format!("Some({value})")
993                    } else {
994                        value
995                    }
996                ));
997            }
998        }
999        let fixture_override = if fixture_overrides.is_empty() {
1000            String::new()
1001        } else {
1002            format!(".with(|factory| {{ {} }})", fixture_overrides.join(" "))
1003        };
1004        let generated = self.render(include_str!("../../templates/resource/test.rs.txt"))
1005            .replace("{{sample-values}}", &self.values(true))
1006            .replace("{{relation-imports}}", &relation_imports)
1007            .replace("{{relation-setup}}", &relation_setup)
1008            .replace("{{relation-input}}", &relation_input)
1009            .replace("{{relation-trait-imports}}", if relation_input.is_empty() { "" } else { "use capy::sea_orm::{EntityTrait, ModelTrait};" })
1010            .replace("{{relation-assertions}}", &relation_assertions)
1011            .replace("{{invalid-reference}}", &invalid_reference)
1012            .replace("{{invalid-decimal}}", &self.fields.iter().filter(|field| field.kind == Kind::Decimal).map(|field| format!("let mut invalid_decimal = input.clone(); invalid_decimal[{:?}] = json!(\"1e2\"); session.post(\"/api/{}\").json(&invalid_decimal).send().await?.assert_status(StatusCode::UNPROCESSABLE_ENTITY); invalid_decimal[{:?}] = json!(1.25); session.post(\"/api/{}\").json(&invalid_decimal).send().await?.assert_status(StatusCode::UNPROCESSABLE_ENTITY);", field.name, self.table(), field.name, self.table())).collect::<Vec<_>>().join("\n"))
1013            .replace("{{input-mut}}", if relation_input.is_empty() { "" } else { "mut " })
1014            .replace("{{guest-read}}", &if self.public_read {format!("let mut guest = app.session();\nguest.get(\"/api/{}\").send().await?.assert_ok();\nguest.get(&path).send().await?.assert_ok().assert_json(row.clone());", self.table())} else {String::new()})
1015            .replace("{{changed-value}}", &format!("let changed: {} = {};\nlet changed = capy::serde_json::to_value(changed).unwrap();\nlet mut updated = input.clone(); updated[{:?}] = changed.clone();\nlet mut expected = row.clone(); expected[{:?}] = changed;", field.wire_type(), field.literal(changed, true), field.name, field.name))
1016            .replace("{{decimal-roundtrip}}", &self.decimal_roundtrip_assertions())
1017            .replace("{{register}}", &if self.auth {format!("session.post(\"/api/{}\").json(json!({{}})).send().await?.assert_status(StatusCode::UNAUTHORIZED);\n{}\nlet registered = session.post(\"/api/auth/register\").json(json!({{\"name\": \"Reader\", \"email\": \"reader@example.test\", \"password\": \"correct-horse-battery-staple\"}})).send().await?;\nregistered.assert_created();\nlet owner_id = registered.json::<Value>()[\"id\"].as_i64().expect(\"user id\");", self.table(), if self.public_read {format!("session.get(\"/api/{}\").send().await?.assert_ok();", self.table())} else {format!("session.get(\"/api/{}\").send().await?.assert_status(StatusCode::UNAUTHORIZED);", self.table())})} else {String::new()})
1018            .replace("{{other-user}}", &if self.auth {format!("let mut other = app.session();\nother.post(\"/api/auth/register\").json(json!({{\"name\": \"Other\", \"email\": \"other@example.test\", \"password\": \"correct-horse-battery-staple\"}})).send().await?.assert_created();\n{}\nother.put(&path).json(&input).send().await?.assert_status(StatusCode::FORBIDDEN);\nother.delete(&path).send().await?.assert_status(StatusCode::FORBIDDEN);\n{}", if self.public_read {"other.get(&path).send().await?.assert_ok();"} else {"other.get(&path).send().await?.assert_status(StatusCode::FORBIDDEN);"}, if self.public_read {format!("assert_eq!(other.get(\"/api/{}\").send().await?.json::<Value>()[\"data\"].as_array().unwrap().len(), 1);", self.table())} else {format!("assert!(other.get(\"/api/{}\").send().await?.json::<Value>()[\"data\"].as_array().unwrap().is_empty());", self.table())})} else {String::new()})
1019            .replace("{{nested-assertions}}", &self.nested_test_assertions())
1020            .replace("{{factory}}", &format!("let fixture = app.factory::<factory::{ty}Factory>(){fixture_override}.create().await?;\nassert!(fixture.id > 0);"))
1021            + &self.default_tests();
1022        let mut generated = generated.replace("crate::app::models::", "application::app::models::");
1023        for assertion in ["assert_ok()", "assert_created()", "assert_no_content()"] {
1024            generated = generated.replace(
1025                &format!(".{assertion}"),
1026                &format!(".{assertion}.assert_contract()"),
1027            );
1028        }
1029        for status in [
1030            "UNAUTHORIZED",
1031            "FORBIDDEN",
1032            "NOT_FOUND",
1033            "UNPROCESSABLE_ENTITY",
1034        ] {
1035            let assertion = format!(".assert_status(StatusCode::{status})");
1036            generated = generated.replace(&assertion, &format!("{assertion}.assert_contract()"));
1037        }
1038        generated
1039    }
1040
1041    fn nested_test_assertions(&self) -> String {
1042        let Some(field) = self.nested_field() else {
1043            return String::new();
1044        };
1045        let parent = self.nested.as_ref().expect("validated nested target");
1046        let bad_parent = match field.kind {
1047            Kind::Integer => "i32::MAX.to_string()",
1048            Kind::Bigint => "i64::MAX.to_string()",
1049            Kind::Uuid => "\"00000000-0000-4000-8000-000000000099\".to_owned()",
1050            _ => unreachable!("validated reference key kind"),
1051        };
1052        let bad_value = match field.kind {
1053            Kind::Integer => "json!(i32::MAX)",
1054            Kind::Bigint => "json!(i64::MAX.to_string())",
1055            Kind::Uuid => "json!(wrong_parent)",
1056            _ => unreachable!("validated reference key kind"),
1057        };
1058        format!("let nested = format!(\"/api/{}/{{}}/{}\", parent_{parent}.id);\nlet nested_list = session.get(&nested).send().await?; nested_list.assert_ok(); assert_eq!(nested_list.json::<Value>()[\"data\"].as_array().unwrap().len(), 1);\nlet nested_show = format!(\"{{nested}}/{{}}\", row[\"id\"]); session.get(&nested_show).send().await?.assert_ok();\nlet wrong_parent = {bad_parent}; let wrong_show = format!(\"/api/{}/{{wrong_parent}}/{}/{{}}\", row[\"id\"]); session.get(&wrong_show).send().await?.assert_status(StatusCode::NOT_FOUND);\nlet mut mismatched = input.clone(); mismatched[{:?}] = {bad_value}; session.post(&nested).json(&mismatched).send().await?.assert_status(StatusCode::NOT_FOUND);\nsession.post(&nested).json(&input).send().await?.assert_created();", plural_table(parent), self.table(), plural_table(parent), self.table(), field.name)
1059    }
1060
1061    fn decimal_roundtrip_assertions(&self) -> String {
1062        self.fields.iter().filter(|field| field.kind == Kind::Decimal).map(|field| {
1063            let (precision, scale) = field.decimal.expect("parsed decimal");
1064            let integer = (precision - scale).min(20) as usize;
1065            let fractional = scale.min(18) as usize;
1066            let whole = if integer == 0 { "0" } else { &"12345678901234567890"[..integer] };
1067            let exact = if fractional == 0 { whole.to_owned() } else { format!("{whole}.{}", &"123456789012345678"[..fractional]) };
1068            format!("let mut precise = updated.clone(); precise[{:?}] = json!({exact:?}); let echoed = session.put(&path).json(&precise).send().await?; echoed.assert_ok(); assert_eq!(echoed.json::<Value>()[{:?}], json!({exact:?}));", field.name, field.name)
1069        }).collect::<Vec<_>>().join("\n")
1070    }
1071
1072    fn test_relation_setup(&self) -> String {
1073        use heck::ToUpperCamelCase;
1074        self.fields.iter().filter_map(|field| field.reference.as_ref().map(|reference| {
1075            let target = &reference.target;
1076            let ty = target.to_upper_camel_case();
1077            let owner = if reference.has_owner {".with(|factory| factory.owner_id = owner_id)"} else {""};
1078            format!("let parent_{target} = app.factory::<{target}_fixture::{ty}Factory>(){owner}.create().await?;")
1079        })).collect::<Vec<_>>().join("\n")
1080    }
1081
1082    fn default_tests(&self) -> String {
1083        if !self.fields.iter().any(|field| field.default.is_some()) {
1084            return String::new();
1085        }
1086        let module = &self.names.module;
1087        let ty = &self.names.ty;
1088        let values = self
1089            .fields
1090            .iter()
1091            .filter(|field| field.default.is_none())
1092            .map(|field| {
1093                if let Some(reference) = &field.reference {
1094                    let value = format!("parent_{}.id", reference.target);
1095                    format!(
1096                        "{}: Set({}),",
1097                        field.name,
1098                        if field.nullable {
1099                            format!("Some({value})")
1100                        } else {
1101                            value
1102                        }
1103                    )
1104                } else {
1105                    format!(
1106                        "{}: Set({}),",
1107                        field.name,
1108                        field.literal(field.sample(), false)
1109                    )
1110                }
1111            })
1112            .collect::<Vec<_>>()
1113            .join("\n");
1114        let assertions = self.fields.iter().filter_map(|field| field.default.as_ref().map(|default| format!("let expected: {} = {};\nassert_eq!(response[{:?}], capy::serde_json::to_value(expected).unwrap());", field.wire_type(), field.literal(default, true), field.name))).collect::<Vec<_>>().join("\n");
1115        let owner = if self.auth {
1116            "let mut session = app.session();\nlet registered = session.post(\"/api/auth/register\").json(json!({\"name\":\"Reader\",\"email\":\"reader@example.test\",\"password\":\"correct-horse-battery-staple\"})).send().await?;\nregistered.assert_created();\nlet owner_id = registered.json::<Value>()[\"id\"].as_i64().unwrap();"
1117        } else {
1118            ""
1119        };
1120        let imports = if self.auth || !values.is_empty() {
1121            "{ActiveModelTrait, Set}"
1122        } else {
1123            "ActiveModelTrait"
1124        };
1125        let relation_setup = self.test_relation_setup();
1126        format!("\n#[capy::tokio::test(crate = \"capy::tokio\")]\nasync fn database_defaults_match_public_contracts() -> Result<()> {{\nuse capy::sea_orm::{imports};\nlet app = TestApp::boot(application::application()).await?;\n{owner}\n{relation_setup}\nlet row = application::app::models::{module}::ActiveModel {{ {} {values} ..Default::default() }}.insert(app.db()).await?;\nlet response = capy::serde_json::to_value(application::app::responses::{module}::{ty}Response::from(row)).unwrap();\n{assertions}\napp.cleanup().await?;\nOk(()) }}", if self.auth {"owner_id: Set(owner_id),"} else {""})
1127    }
1128}
1129
1130fn register(
1131    plan: &mut EditPlan<'_>,
1132    path: &str,
1133    module: &str,
1134    exports: &str,
1135    kind: Generator,
1136    names: &GeneratedNames,
1137) -> Result<()> {
1138    let registry = plan.read(path)?;
1139    names.check_registry(&registry, module, kind)?;
1140    plan.replace(path, format!("{registry}\npub mod {module};\n{exports}\n"))
1141}
1142
1143fn ensure_group(plan: &mut EditPlan<'_>, module: &str) -> Result<()> {
1144    let path = format!("app/{module}/mod.rs");
1145    if !plan.exists(&path) {
1146        register(
1147            plan,
1148            "app/mod.rs",
1149            module,
1150            "",
1151            Generator::Controller,
1152            &GeneratedNames::new(module)?,
1153        )?;
1154        plan.create(&path, format!("//! Application-owned {module}.\n"))?;
1155    }
1156    Ok(())
1157}