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
11pub 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#[derive(Clone, Copy, Debug, PartialEq, Eq)]
24pub enum AccessProfile {
25 Private,
27 PublicRead,
29}
30
31pub 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
43pub 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 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(®istry, 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}