mod evolve;
mod field;
mod frontend;
pub use evolve::{add_field, add_index};
use crate::{edit::EditPlan, names::GeneratedNames, Generator};
use anyhow::{bail, Context, Result};
use field::{Field, Kind};
use std::path::{Path, PathBuf};
/// Generate application-owned CRUD, explicit contracts, migrations, tests and fixtures.
/// Existing files are never overwritten. Registry changes commit together or roll back.
pub fn make_resource(
root: &Path,
name: &str,
definitions: &[String],
frontend: bool,
) -> Result<Vec<PathBuf>> {
make_resource_with_options(root, name, definitions, frontend, None, None)
}
/// Explicit resource authorization shape. Application policies remain editable code.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum AccessProfile {
/// Authenticated owner-scoped reads and authenticated mutations.
Private,
/// Public list/show; authenticated, owner-controlled mutations.
PublicRead,
}
/// Generate a resource with an explicit access profile.
/// `None` preserves the historical default: private with auth, public without auth.
pub fn make_resource_with_access(
root: &Path,
name: &str,
definitions: &[String],
frontend: bool,
access: Option<AccessProfile>,
) -> Result<Vec<PathBuf>> {
make_resource_with_options(root, name, definitions, frontend, access, None)
}
/// Generate optional nested list/create/show conventions for one reference target.
pub fn make_resource_with_options(
root: &Path,
name: &str,
definitions: &[String],
frontend: bool,
access: Option<AccessProfile>,
nested: Option<&str>,
) -> Result<Vec<PathBuf>> {
let names = GeneratedNames::new(name)?;
if names.module.len() > 40 {
bail!("Resource names must be at most 40 characters after snake_case conversion.");
}
let mut fields = Field::parse_all(definitions)?;
for field in &mut fields {
if field.kind == Kind::Enum {
field.enum_resource = Some(names.module.clone());
}
}
let mut plan = EditPlan::new(root)?;
for field in &mut fields {
if let Some(reference) = &mut field.reference {
let path = format!("app/models/{}.rs", reference.target);
let source = plan.read(&path).with_context(|| {
format!(
"Generate the referenced resource {} first; no files changed.",
reference.target
)
})?;
let (kind, has_owner) = reference_model_info(&source).with_context(|| format!(
"Cannot use {path} as a reference target; its Model must have an i32, i64 or UUID id. No files changed."
))?;
field.kind = kind;
reference.has_owner = has_owner;
plan.read(&format!("tests/factories/{}.rs", reference.target)).with_context(|| format!(
"Generate the referenced resource {} first so its factory is available; no files changed.", reference.target
))?;
}
}
if fields.iter().all(|field| field.reference.is_some()) {
bail!("A resource needs at least one non-reference field for its public feature.");
}
let nested = nested
.map(GeneratedNames::new)
.transpose()?
.map(|names| names.module);
if let Some(parent) = &nested {
if !fields.iter().any(|field| {
field
.reference
.as_ref()
.is_some_and(|reference| &reference.target == parent)
}) {
bail!("--nested {parent} requires a {parent}_id:references:Parent field; no files changed.");
}
}
let manifest = plan.read("Cargo.toml")?.parse::<toml_edit::DocumentMut>()?;
let crate_name = manifest["package"]["name"]
.as_str()
.context("Missing package.name")?
.replace('-', "_");
let auth = manifest
.get("dependencies")
.and_then(|v| v.get("capy"))
.and_then(|v| v.get("features"))
.and_then(toml_edit::Item::as_array)
.is_some_and(|features| features.iter().any(|f| f.as_str() == Some("auth")));
if access.is_some() && !auth {
bail!("--access private/public-read requires authentication; run capy make:auth first.");
}
if auth && fields.iter().any(|f| f.name == "owner_id") {
bail!(
"owner_id is generated from the authenticated identity; it cannot be an input field."
);
}
if auth
&& fields.iter().any(|field| {
field
.reference
.as_ref()
.is_some_and(|reference| reference.target == "user")
})
{
bail!("Authenticated resources already belong to User through generated owner_id; use that relation for the author/owner. No files changed.");
}
let resource = Resource {
names,
fields,
auth,
public_read: access == Some(AccessProfile::PublicRead),
nested,
crate_name,
};
resource.backend(&mut plan)?;
if frontend {
resource.frontend(root, &mut plan)?;
}
plan.commit()
}
struct Resource {
names: GeneratedNames,
fields: Vec<Field>,
auth: bool,
public_read: bool,
nested: Option<String>,
crate_name: String,
}
fn reference_model_info(source: &str) -> Result<(Kind, bool)> {
let model = syn::parse_file(source)?
.items
.into_iter()
.find_map(|item| match item {
syn::Item::Struct(item) if item.ident == "Model" => Some(item),
_ => None,
})
.context("Missing Model struct")?;
let (id, has_owner) = match model.fields {
syn::Fields::Named(fields) => {
let has_owner = fields.named.iter().any(|field| {
field
.ident
.as_ref()
.is_some_and(|ident| ident == "owner_id")
});
(
fields
.named
.into_iter()
.find(|field| field.ident.as_ref().is_some_and(|ident| ident == "id"))
.context("Missing Model.id")?,
has_owner,
)
}
_ => anyhow::bail!("Model needs named fields"),
};
let syn::Type::Path(path) = id.ty else {
anyhow::bail!("Unsupported Model.id type")
};
match path
.path
.segments
.last()
.map(|segment| segment.ident.to_string())
.as_deref()
{
Some("i32") => Ok((Kind::Integer, has_owner)),
Some("i64") => Ok((Kind::Bigint, has_owner)),
Some("Uuid") => Ok((Kind::Uuid, has_owner)),
_ => anyhow::bail!("Unsupported Model.id type"),
}
}
impl Resource {
fn table(&self) -> String {
plural_table(&self.names.module)
}
fn render(&self, template: &str) -> String {
use heck::ToUpperCamelCase;
template
.replace("{{plural-type}}", &self.table().to_upper_camel_case())
.replace("{{module}}", &self.names.module)
.replace("{{type}}", &self.names.ty)
.replace("{{table}}", &self.table())
.replace("{{crate}}", &self.crate_name)
}
}
fn plural_table(name: &str) -> String {
if name.ends_with('y')
&& !["ay", "ey", "iy", "oy", "uy"]
.iter()
.any(|suffix| name.ends_with(suffix))
{
format!("{}ies", &name[..name.len() - 1])
} else if name.ends_with(['s', 'x', 'z']) || name.ends_with("ch") || name.ends_with("sh") {
format!("{name}es")
} else {
format!("{name}s")
}
}
impl Resource {
fn enum_definitions(&self) -> String {
use heck::ToUpperCamelCase;
self.fields.iter().filter_map(|field| field.enum_values.as_ref().map(|values| {
let ty = format!("{}{}", self.names.ty, field.name.to_upper_camel_case());
let variants = values.iter().map(|value| format!("#[sea_orm(string_value = {value:?})] {} ,", value.to_upper_camel_case())).collect::<Vec<_>>().join("\n");
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} }}")
})).collect::<Vec<_>>().join("\n")
}
fn backend(&self, plan: &mut EditPlan<'_>) -> Result<()> {
let module = &self.names.module;
let ty = &self.names.ty;
let table = self.table();
let factory = plan.read("src/bootstrap.rs").context("Resource tests require the shared application() factory. See the 0.9 upgrade guide; no files changed")?;
if !factory.contains("pub fn application()") {
bail!("Expose the shared application() factory before generating resource tests; no files changed.");
}
register(
plan,
"app/models/mod.rs",
module,
&format!("pub use {module}::Entity as {ty};\npub use {module}::Model as {ty}Model;"),
Generator::Model,
&self.names,
)?;
let model_fields = self
.fields
.iter()
.map(|f| format!("pub {}: {},", f.name, f.entity_type()))
.collect::<Vec<_>>()
.join("\n");
let relation_variants = self.relation_variants();
let related_impls = self.related_impls();
let enums = self.enum_definitions();
plan.create(&format!("app/models/{module}.rs"), format!(
"//! 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",
if self.auth { "pub owner_id: i64," } else { "" }))?;
let reverse_relations = self.reverse_relations();
if !reverse_relations.is_empty() {
let name = format!("{module}_relations");
register(
plan,
"app/models/mod.rs",
&name,
"",
Generator::Model,
&GeneratedNames::new(&name)?,
)?;
plan.create(
&format!("app/models/{name}.rs"),
format!("//! Reverse relations live outside existing application-owned models.\nuse capy::sea_orm::entity::prelude::*;\n{reverse_relations}"),
)?;
}
ensure_group(plan, "responses")?;
register(
plan,
"app/responses/mod.rs",
module,
"",
Generator::Controller,
&self.names,
)?;
let response_fields = self
.fields
.iter()
.map(|f| {
if f.kind == Kind::Decimal {
format!(
"#[schemars(extend(\"pattern\" = r\"{}\"))] pub {}: {},",
f.decimal_pattern(),
f.name,
f.wire_type()
)
} else {
format!("pub {}: {},", f.name, f.wire_type())
}
})
.collect::<Vec<_>>()
.join("\n");
let conversions = self
.fields
.iter()
.map(|f| {
let name = &f.name;
let value = if f.kind == Kind::Bigint {
if f.nullable {
format!("row.{name}.map(|value| value.to_string())")
} else {
format!("row.{name}.to_string()")
}
} else {
format!("row.{name}")
};
format!("{name}: {value},")
})
.collect::<Vec<_>>()
.join("\n");
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} }} }} }}"))?;
for action in ["create", "update"] {
let request_module = format!("{action}_{module}");
register(
plan,
"app/requests/mod.rs",
&request_module,
"",
Generator::Request,
&GeneratedNames::new(&request_module)?,
)?;
plan.create(
&format!("app/requests/{request_module}.rs"),
self.request(action == "create"),
)?;
}
register(
plan,
"app/controllers/mod.rs",
&format!("{module}_controller"),
"",
Generator::Controller,
&self.names,
)?;
plan.create(
&format!("app/controllers/{module}_controller.rs"),
self.controller(),
)?;
if self.auth {
ensure_group(plan, "policies")?;
register(
plan,
"app/policies/mod.rs",
&format!("{module}_policy"),
"",
Generator::Controller,
&self.names,
)?;
plan.create(
&format!("app/policies/{module}_policy.rs"),
self.render(include_str!("../../templates/resource/policy.rs.txt")),
)?;
}
register(
plan,
"routes/mod.rs",
&table,
"",
Generator::Controller,
&GeneratedNames::new(&table)?,
)?;
plan.create(
&format!("routes/{table}.rs"),
self.render(include_str!("../../templates/resource/routes.rs.txt"))
.replace(
"{{read-contract}}",
if self.auth && !self.public_read {
".authenticated().error(403)"
} else {
""
},
)
.replace(
"{{write-contract}}",
if self.auth {
".authenticated().error(403)"
} else {
""
},
)
.replace("{{nested-routes}}", &self.nested_routes()),
)?;
plan.anchor(
"routes/api.rs",
"// capy:routes",
&format!(".merge(crate::routes::{table}::routes())"),
)?;
// Ordering is the explicit registry's order, not a wall-clock filename.
let migration = format!("m_resource_{module}");
self.names.check_registry(
&plan.read("database/migrations/mod.rs")?,
&migration,
Generator::Migration,
)?;
plan.create(
&format!("database/migrations/{migration}.rs"),
self.migration(),
)?;
plan.anchor(
"database/migrations/mod.rs",
"// capy:modules",
&format!("mod {migration};"),
)?;
plan.anchor(
"database/migrations/mod.rs",
"// capy:migrations",
&format!("Box::new({migration}::Migration),"),
)?;
plan.create(&format!("database/seeds/{table}.rs"), self.seed())?;
plan.anchor(
"database/seeds.rs",
"// capy:seed-modules",
&format!("mod {table};"),
)?;
plan.anchor(
"database/seeds.rs",
"// capy:seeds",
&format!("{table}::run(&ctx).await?;"),
)?;
plan.create(&format!("tests/factories/{module}.rs"), self.factory())?;
plan.create(&format!("tests/{table}.rs"), self.tests())?;
Ok(())
}
fn relation_variants(&self) -> String {
use heck::ToUpperCamelCase;
let mut variants = Vec::new();
if self.auth {
variants.push("#[sea_orm(belongs_to = \"super::user::Entity\", from = \"Column::OwnerId\", to = \"super::user::Column::Id\", on_delete = \"Cascade\")] Owner,".to_owned());
}
for field in &self.fields {
if let Some(reference) = &field.reference {
let target = &reference.target;
let column = field.name.to_upper_camel_case();
let variant = target.to_upper_camel_case();
let delete = reference.on_delete.sea_orm();
variants.push(format!("#[sea_orm(belongs_to = \"super::{target}::Entity\", from = \"Column::{column}\", to = \"super::{target}::Column::Id\", on_delete = \"{delete}\")] {variant},"));
}
}
variants.join("\n")
}
fn nested_field(&self) -> Option<&Field> {
let parent = self.nested.as_ref()?;
self.fields.iter().find(|field| {
field
.reference
.as_ref()
.is_some_and(|reference| &reference.target == parent)
})
}
fn nested_routes(&self) -> String {
use heck::ToUpperCamelCase;
let Some(field) = self.nested_field() else {
return String::new();
};
let parent = self.nested.as_ref().expect("validated nested target");
let path = format!(
"/{}/{{{}}}/{}",
plural_table(parent),
field.name,
self.table()
);
let show_path = format!("{path}/{{id}}");
let parent_type = parent.to_upper_camel_case();
let child_type = &self.names.ty;
let plural_type = self.table().to_upper_camel_case();
let key_type = field
.entity_type()
.trim_start_matches("Option<")
.trim_end_matches('>')
.to_owned();
let read_contract = if self.auth && !self.public_read {
".authenticated().error(403)"
} else {
""
};
let write_contract = if self.auth {
".authenticated().error(403)"
} else {
""
};
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)
}
fn related_impls(&self) -> String {
use heck::ToUpperCamelCase;
let mut relations = Vec::new();
if self.auth {
relations.push("impl Related<super::user::Entity> for Entity { fn to() -> RelationDef { Relation::Owner.def() } }".to_owned());
}
for field in &self.fields {
if let Some(reference) = &field.reference {
let target = &reference.target;
let variant = target.to_upper_camel_case();
relations.push(format!("impl Related<super::{target}::Entity> for Entity {{ fn to() -> RelationDef {{ Relation::{variant}.def() }} }}"));
}
}
relations.join("\n")
}
fn reverse_relations(&self) -> String {
use heck::ToUpperCamelCase;
let child = &self.names.module;
let mut relations = Vec::new();
if self.auth {
relations.push(format!("impl Related<super::{child}::Entity> for super::user::Entity {{ fn to() -> RelationDef {{ super::{child}::Relation::Owner.def().rev() }} }}"));
}
for field in &self.fields {
if let Some(reference) = &field.reference {
let target = &reference.target;
let variant = target.to_upper_camel_case();
relations.push(format!("impl Related<super::{child}::Entity> for super::{target}::Entity {{ fn to() -> RelationDef {{ super::{child}::Relation::{variant}.def().rev() }} }}"));
}
}
relations.join("\n")
}
fn request(&self, create: bool) -> String {
let name = format!(
"{}{}Request",
if create { "Create" } else { "Update" },
self.names.ty
);
let mut defaults = String::new();
let mut fields = String::new();
for field in &self.fields {
let n = &field.name;
if create {
if let Some(value) = &field.default {
fields.push_str(&format!("#[serde(default = \"default_{n}\")]\n"));
defaults.push_str(&format!(
"fn default_{n}() -> {} {{ {} }}\n",
field.wire_type(),
field.literal(value, true)
));
}
}
if matches!(field.kind, Kind::String | Kind::Text) {
fields.push_str(&format!(
"#[validate(length(min = 1, max = {}))]\n",
if field.kind == Kind::String {
255
} else {
50_000
}
));
} else if field.kind == Kind::Bigint {
fields.push_str("#[validate(custom(function = \"valid_bigint\"))]\n");
} else if field.kind == Kind::Decimal {
fields.push_str(&format!("#[validate(custom(function = \"valid_{n}\"))]\n#[schemars(extend(\"pattern\" = r\"{}\"))]\n", field.decimal_pattern()));
let (precision, scale) = field.decimal.expect("parsed decimal");
let integer = precision - scale;
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"));
}
fields.push_str(&format!("pub {n}: {},\n", field.wire_type()));
}
if self.fields.iter().any(|f| f.kind == Kind::Bigint) {
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");
}
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}")
}
fn input_value(field: &Field) -> String {
let n = &field.name;
if field.kind == Kind::Bigint {
let expr = if field.nullable {
format!("input.{n}.map(|value| value.parse::<i64>()).transpose()")
} else {
format!("input.{n}.parse::<i64>()")
};
format!("{expr}.map_err(|_| AppError::Validation([({n:?}.into(), vec![\"Must be an integer within i64 bounds.\".into()])].into()))?")
} else {
format!("input.{n}")
}
}
fn controller(&self) -> String {
let mut source = self.render(include_str!("../../templates/resource/controller.rs.txt"));
let module = &self.names.module;
let ty = &self.names.ty;
let needs_filter = self.nested.is_some() || (self.auth && !self.public_read);
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 {""}))
.replace("{{read-auth-param}}", if self.auth && !self.public_read {"AuthUser(user): AuthUser, "} else {""})
.replace("{{write-auth-param}}", if self.auth {"AuthUser(user): AuthUser, "} else {""})
.replace("{{owner-filter}}", &if self.auth && !self.public_read {format!(".filter({module}::Column::OwnerId.eq(user.id))")} else {String::new()})
.replace("{{owner-value}}", if self.auth {"owner_id: Set(user.id),"} else {""});
for (action, resource) in [
("list", "None"),
("create", "None"),
("read", "Some(&row)"),
("update", "Some(&row)"),
("delete", "Some(&row)"),
] {
use heck::ToUpperCamelCase;
source = source.replace(
&format!("{{{{authorize-{action}}}}}"),
&if self.auth && !(self.public_read && matches!(action, "list" | "read")) {
format!(
"{ty}Policy::authorize(&user, {ty}Action::{}, &{resource})?;",
action.to_upper_camel_case()
)
} else {
String::new()
},
);
}
let reference_checks = self.fields.iter().filter_map(|field| field.reference.as_ref().map(|reference| {
let name = &field.name;
let target = &reference.target;
let value = if field.kind == Kind::Bigint {
if field.nullable {
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()))?")
} else {
format!("Some(input.{name}.parse::<i64>().map_err(|_| AppError::Validation([({name:?}.into(), vec![\"Must be an integer within i64 bounds.\".into()])].into()))?)")
}
} else if field.nullable {
format!("input.{name}")
} else {
format!("Some(input.{name})")
};
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())); }} }}")
})).collect::<Vec<_>>().join("\n");
let source = source
.replace("{{create-reference-checks}}", &reference_checks)
.replace("{{update-reference-checks}}", &reference_checks)
.replace(
"{{create-values}}",
&self
.fields
.iter()
.map(|f| format!("{}: Set({}),", f.name, Self::input_value(f)))
.collect::<Vec<_>>()
.join("\n"),
)
.replace(
"{{update-values}}",
&self
.fields
.iter()
.map(|f| format!("row.{} = Set({});", f.name, Self::input_value(f)))
.collect::<Vec<_>>()
.join("\n"),
);
format!("{source}\n{}", self.nested_controller())
}
fn nested_controller(&self) -> String {
use heck::ToUpperCamelCase;
let Some(field) = self.nested_field() else {
return String::new();
};
let parent = self.nested.as_ref().expect("validated nested target");
let parent_type = match field.kind {
Kind::Integer => "i32",
Kind::Bigint => "i64",
Kind::Uuid => "capy::uuid::Uuid",
_ => unreachable!("validated reference key kind"),
};
let parent_mismatch = match (field.kind, field.nullable) {
(Kind::Bigint, true) => format!(
"input.{}.as_deref().and_then(|id| id.parse::<i64>().ok()) != Some(parent_id)",
field.name
),
(Kind::Bigint, false) => format!(
"input.{}.parse::<i64>().ok() != Some(parent_id)",
field.name
),
(_, true) => format!("input.{} != Some(parent_id)", field.name),
(_, false) => format!("input.{} != parent_id", field.name),
};
let read_auth = if self.auth && !self.public_read {
"AuthUser(user): AuthUser, "
} else {
""
};
let write_auth = if self.auth {
"AuthUser(user): AuthUser, "
} else {
""
};
let list_policy = if self.auth && !self.public_read {
format!(
"{}Policy::authorize(&user, {}Action::List, &None)?;",
self.names.ty, self.names.ty
)
} else {
String::new()
};
let read_policy = if self.auth && !self.public_read {
format!(
"{}Policy::authorize(&user, {}Action::Read, &Some(&row))?;",
self.names.ty, self.names.ty
)
} else {
String::new()
};
let owner_filter = if self.auth && !self.public_read {
format!(
".filter({}::Column::OwnerId.eq(user.id))",
self.names.module
)
} else {
String::new()
};
let create_call = if self.auth {
"create(AuthUser(user), Context(ctx), Validated(input)).await"
} else {
"create(Context(ctx), Validated(input)).await"
};
self.render(include_str!(
"../../templates/resource/nested-controller.rs.txt"
))
.replace("{{nested-read-auth}}", read_auth)
.replace("{{nested-write-auth}}", write_auth)
.replace("{{parent-module}}", parent)
.replace("{{parent-type}}", parent_type)
.replace("{{parent-column}}", &field.name.to_upper_camel_case())
.replace("{{parent-mismatch}}", &parent_mismatch)
.replace("{{nested-authorize-list}}", &list_policy)
.replace("{{nested-authorize-read}}", &read_policy)
.replace("{{nested-owner-filter}}", &owner_filter)
.replace("{{create-call}}", create_call)
}
fn migration(&self) -> String {
let table = self.table();
let mut columns = String::new();
let mut indexes = String::new();
let mut checks = String::new();
for (i, field) in self.fields.iter().enumerate() {
let ty = match field.kind {
Kind::String => "string_len(255)",
Kind::Text => "text()",
Kind::Boolean => "boolean()",
Kind::Integer => "integer()",
Kind::Bigint => "big_integer()",
Kind::Float => "double()",
Kind::Uuid => "uuid()",
Kind::Datetime => "timestamp_with_time_zone()",
Kind::Date => "date()",
Kind::Enum => "string_len(255)",
Kind::Decimal => "string_len(41)",
};
let mut column = format!(".col(ColumnDef::new(Alias::new({:?})).{ty}", field.name);
if !field.nullable {
column.push_str(".not_null()");
}
if let Some(default) = &field.default {
let value = if field.kind == Kind::Enum {
format!("{default:?}")
} else if field.kind == Kind::Uuid {
let bytes = if field.nullable {
"value.map(|id| id.as_bytes().to_vec())"
} else {
"value.as_bytes().to_vec()"
};
format!("if manager.get_database_backend() == capy::sea_orm::DbBackend::Sqlite {{ Expr::value({bytes}) }} else {{ Expr::value(value) }}")
} else {
"value".into()
};
if field.kind == Kind::Enum {
column.push_str(&format!(".default({value})"));
} else {
column.push_str(&format!(
".default({{let value: {} = {}; {value}}})",
field.entity_type(),
field.literal(default, false)
));
}
}
column.push_str(")\n");
columns.push_str(&column);
if let Some(values) = &field.enum_values {
let allowed = values
.iter()
.map(|value| format!("{value:?}"))
.collect::<Vec<_>>()
.join(", ");
checks.push_str(&format!(
".check(Expr::col(Alias::new({:?})).is_in([{allowed}]))\n",
field.name
));
}
if let Some(reference) = &field.reference {
let target_table = plural_table(&reference.target);
let delete = reference.on_delete.sea_orm();
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));
}
if field.unique || field.index {
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 {""}));
}
}
if self.auth {
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");
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")));
}
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 }} }}")
}
fn values(&self, wire: bool) -> String {
self.fields
.iter()
.map(|f| format!("{}: {},", f.name, f.literal(f.sample(), wire)))
.collect::<Vec<_>>()
.join("\n")
}
fn seed(&self) -> String {
let module = &self.names.module;
let owner = if self.auth {
"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"
} else {
""
};
let reference_setup = self.fields.iter().filter_map(|field| field.reference.as_ref().map(|reference| {
let target = &reference.target;
format!("let Some(reference_{target}) = crate::app::models::{target}::Entity::find().one(ctx.transaction).await? else {{ return Ok(()); }};")
})).collect::<Vec<_>>().join("\n");
let values = self
.fields
.iter()
.map(|f| {
if let Some(reference) = &f.reference {
let value = format!("reference_{}.id", reference.target);
format!(
"{}: Set({}),",
f.name,
if f.nullable {
format!("Some({value})")
} else {
value
}
)
} else {
format!("{}: Set({}),", f.name, f.literal(f.sample(), false))
}
})
.collect::<Vec<_>>()
.join("\n");
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 {""})
}
fn factory(&self) -> String {
let module = &self.names.module;
let ty = &self.names.ty;
let fields = self
.fields
.iter()
.map(|f| format!("pub {}: {},", f.name, f.entity_type()))
.collect::<Vec<_>>()
.join("\n");
let values = self
.fields
.iter()
.map(|f| format!("{}: Set(self.{}),", f.name, f.name))
.collect::<Vec<_>>()
.join("\n");
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))
}
fn tests(&self) -> String {
let ty = &self.names.ty;
let field = self
.fields
.iter()
.find(|field| field.reference.is_none())
.expect("validated non-reference field");
let changed = match field.kind {
Kind::String | Kind::Text => {
if field.sample() == "Updated" {
"Changed again"
} else {
"Updated"
}
}
Kind::Boolean => {
if field.sample() == "true" {
"false"
} else {
"true"
}
}
Kind::Integer | Kind::Bigint | Kind::Float => {
if field.sample() == "2" {
"3"
} else {
"2"
}
}
Kind::Uuid => "00000000-0000-4000-8000-000000000002",
Kind::Datetime => "2026-02-01T00:00:00+00:00",
Kind::Date => "2026-02-01",
Kind::Enum => field
.enum_values
.as_ref()
.expect("parsed enum")
.iter()
.find(|value| value.as_str() != field.sample())
.expect("at least two enum variants"),
Kind::Decimal => {
let (precision, scale) = field.decimal.expect("parsed decimal");
if scale == 0 {
"2"
} else if precision == scale {
"0.2"
} else if scale == 1 {
"1.3"
} else {
"1.26"
}
}
};
let relation_imports = self
.fields
.iter()
.filter_map(|field| {
field.reference.as_ref().map(|reference| {
let target = &reference.target;
format!("#[path = \"factories/{target}.rs\"] mod {target}_fixture;")
})
})
.collect::<Vec<_>>()
.join("\n");
let relation_setup = self.test_relation_setup();
let relation_input = self
.fields
.iter()
.filter_map(|field| {
field.reference.as_ref().map(|reference| {
let name = &field.name;
let parent = format!("parent_{}", reference.target);
let value = if field.kind == Kind::Bigint {
format!("{parent}.id.to_string()")
} else {
format!("{parent}.id")
};
format!("input[{name:?}] = json!({value});")
})
})
.collect::<Vec<_>>()
.join("\n");
let relation_assertions = if relation_input.is_empty() {
String::new()
} else {
let child = &self.names.module;
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();")];
for field in &self.fields {
if let Some(reference) = &field.reference {
let target = &reference.target;
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);"));
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);"));
}
}
assertions.join("\n")
};
let invalid_reference = self.fields.iter().find(|field| field.reference.is_some()).map(|field| {
let invalid = match field.kind {
Kind::Integer => "json!(i32::MAX)",
Kind::Bigint => "json!(i64::MAX.to_string())",
Kind::Uuid => "json!(\"00000000-0000-4000-8000-000000000099\")",
_ => unreachable!("validated reference key kind"),
};
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())
}).unwrap_or_default();
let mut fixture_overrides = Vec::new();
if self.auth {
fixture_overrides.push("factory.owner_id = owner_id;".to_owned());
}
for field in &self.fields {
if let Some(reference) = &field.reference {
let value = format!("parent_{}.id", reference.target);
fixture_overrides.push(format!(
"factory.{} = {};",
field.name,
if field.nullable {
format!("Some({value})")
} else {
value
}
));
}
}
let fixture_override = if fixture_overrides.is_empty() {
String::new()
} else {
format!(".with(|factory| {{ {} }})", fixture_overrides.join(" "))
};
let generated = self.render(include_str!("../../templates/resource/test.rs.txt"))
.replace("{{sample-values}}", &self.values(true))
.replace("{{relation-imports}}", &relation_imports)
.replace("{{relation-setup}}", &relation_setup)
.replace("{{relation-input}}", &relation_input)
.replace("{{relation-trait-imports}}", if relation_input.is_empty() { "" } else { "use capy::sea_orm::{EntityTrait, ModelTrait};" })
.replace("{{relation-assertions}}", &relation_assertions)
.replace("{{invalid-reference}}", &invalid_reference)
.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"))
.replace("{{input-mut}}", if relation_input.is_empty() { "" } else { "mut " })
.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()})
.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))
.replace("{{decimal-roundtrip}}", &self.decimal_roundtrip_assertions())
.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()})
.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()})
.replace("{{nested-assertions}}", &self.nested_test_assertions())
.replace("{{factory}}", &format!("let fixture = app.factory::<factory::{ty}Factory>(){fixture_override}.create().await?;\nassert!(fixture.id > 0);"))
+ &self.default_tests();
let mut generated = generated.replace("crate::app::models::", "application::app::models::");
for assertion in ["assert_ok()", "assert_created()", "assert_no_content()"] {
generated = generated.replace(
&format!(".{assertion}"),
&format!(".{assertion}.assert_contract()"),
);
}
for status in [
"UNAUTHORIZED",
"FORBIDDEN",
"NOT_FOUND",
"UNPROCESSABLE_ENTITY",
] {
let assertion = format!(".assert_status(StatusCode::{status})");
generated = generated.replace(&assertion, &format!("{assertion}.assert_contract()"));
}
generated
}
fn nested_test_assertions(&self) -> String {
let Some(field) = self.nested_field() else {
return String::new();
};
let parent = self.nested.as_ref().expect("validated nested target");
let bad_parent = match field.kind {
Kind::Integer => "i32::MAX.to_string()",
Kind::Bigint => "i64::MAX.to_string()",
Kind::Uuid => "\"00000000-0000-4000-8000-000000000099\".to_owned()",
_ => unreachable!("validated reference key kind"),
};
let bad_value = match field.kind {
Kind::Integer => "json!(i32::MAX)",
Kind::Bigint => "json!(i64::MAX.to_string())",
Kind::Uuid => "json!(wrong_parent)",
_ => unreachable!("validated reference key kind"),
};
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)
}
fn decimal_roundtrip_assertions(&self) -> String {
self.fields.iter().filter(|field| field.kind == Kind::Decimal).map(|field| {
let (precision, scale) = field.decimal.expect("parsed decimal");
let integer = (precision - scale).min(20) as usize;
let fractional = scale.min(18) as usize;
let whole = if integer == 0 { "0" } else { &"12345678901234567890"[..integer] };
let exact = if fractional == 0 { whole.to_owned() } else { format!("{whole}.{}", &"123456789012345678"[..fractional]) };
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)
}).collect::<Vec<_>>().join("\n")
}
fn test_relation_setup(&self) -> String {
use heck::ToUpperCamelCase;
self.fields.iter().filter_map(|field| field.reference.as_ref().map(|reference| {
let target = &reference.target;
let ty = target.to_upper_camel_case();
let owner = if reference.has_owner {".with(|factory| factory.owner_id = owner_id)"} else {""};
format!("let parent_{target} = app.factory::<{target}_fixture::{ty}Factory>(){owner}.create().await?;")
})).collect::<Vec<_>>().join("\n")
}
fn default_tests(&self) -> String {
if !self.fields.iter().any(|field| field.default.is_some()) {
return String::new();
}
let module = &self.names.module;
let ty = &self.names.ty;
let values = self
.fields
.iter()
.filter(|field| field.default.is_none())
.map(|field| {
if let Some(reference) = &field.reference {
let value = format!("parent_{}.id", reference.target);
format!(
"{}: Set({}),",
field.name,
if field.nullable {
format!("Some({value})")
} else {
value
}
)
} else {
format!(
"{}: Set({}),",
field.name,
field.literal(field.sample(), false)
)
}
})
.collect::<Vec<_>>()
.join("\n");
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");
let owner = if self.auth {
"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();"
} else {
""
};
let imports = if self.auth || !values.is_empty() {
"{ActiveModelTrait, Set}"
} else {
"ActiveModelTrait"
};
let relation_setup = self.test_relation_setup();
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 {""})
}
}
fn register(
plan: &mut EditPlan<'_>,
path: &str,
module: &str,
exports: &str,
kind: Generator,
names: &GeneratedNames,
) -> Result<()> {
let registry = plan.read(path)?;
names.check_registry(®istry, module, kind)?;
plan.replace(path, format!("{registry}\npub mod {module};\n{exports}\n"))
}
fn ensure_group(plan: &mut EditPlan<'_>, module: &str) -> Result<()> {
let path = format!("app/{module}/mod.rs");
if !plan.exists(&path) {
register(
plan,
"app/mod.rs",
module,
"",
Generator::Controller,
&GeneratedNames::new(module)?,
)?;
plan.create(&path, format!("//! Application-owned {module}.\n"))?;
}
Ok(())
}