mod field;
mod frontend;
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>> {
let names = GeneratedNames::new(name)?;
if names.module.len() > 40 {
bail!("Resource names must be at most 40 characters after snake_case conversion.");
}
let fields = Field::parse_all(definitions)?;
let mut plan = EditPlan::new(root)?;
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 auth && fields.iter().any(|f| f.name == "owner_id") {
bail!(
"owner_id is generated from the authenticated identity; it cannot be an input field."
);
}
let resource = Resource {
names,
fields,
auth,
crate_name,
};
resource.backend(&mut plan)?;
if frontend {
resource.frontend(root, &mut plan)?;
}
plan.commit()
}
struct Resource {
names: GeneratedNames,
fields: Vec<Field>,
auth: bool,
crate_name: String,
}
impl Resource {
fn table(&self) -> String {
let name = &self.names.module;
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")
}
}
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 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");
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#[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 {{}}\nimpl ActiveModelBehavior for ActiveModel {{}}\n",
if self.auth { "pub owner_id: i64," } else { "" }))?;
ensure_group(plan, "responses")?;
register(
plan,
"app/responses/mod.rs",
module,
"",
Generator::Controller,
&self.names,
)?;
let response_fields = self
.fields
.iter()
.map(|f| 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(
"{{auth-contract}}",
if self.auth {
".authenticated().error(403)"
} else {
""
},
),
)?;
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 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");
}
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;
source = source.replace("{{auth-imports}}", &if self.auth {format!("use capy::{{auth::{{AuthUser, Policy}}, sea_orm::{{ColumnTrait, QueryFilter}}}};\nuse crate::app::policies::{module}_policy::{{{ty}Policy, {ty}Action}};")} else {String::new()})
.replace("{{auth-param}}", if self.auth {"AuthUser(user): AuthUser, "} else {""})
.replace("{{owner-filter}}", &if self.auth {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 {
format!(
"{ty}Policy::authorize(&user, {ty}Action::{}, &{resource})?;",
action.to_upper_camel_case()
)
} else {
String::new()
},
);
}
source
.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"),
)
}
fn migration(&self) -> String {
let table = self.table();
let mut columns = String::new();
let mut indexes = 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()",
};
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::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()
};
column.push_str(&format!(
".default({{let value: {} = {}; {value}}})",
field.entity_type(),
field.literal(default, false)
));
}
column.push_str(")\n");
columns.push_str(&column);
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}.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 values = self
.fields
.iter()
.map(|f| 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{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 {""})
}
fn tests(&self) -> String {
let ty = &self.names.ty;
let field = &self.fields[0];
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",
};
self.render(include_str!("../../templates/resource/test.rs.txt"))
.replace("{{sample-values}}", &self.values(true))
.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; expected[{:?}] = changed;", field.wire_type(), field.literal(changed, true), field.name, field.name))
.replace("{{register}}", &if self.auth {format!("session.get(\"/api/{}\").send().await?.assert_status(StatusCode::UNAUTHORIZED);\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())} 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();\nother.get(&path).send().await?.assert_status(StatusCode::FORBIDDEN);\nother.put(&path).json(&input).send().await?.assert_status(StatusCode::FORBIDDEN);\nother.delete(&path).send().await?.assert_status(StatusCode::FORBIDDEN);\nassert!(other.get(\"/api/{}\").send().await?.json::<Value>()[\"data\"].as_array().unwrap().is_empty());", self.table())} else {String::new()})
.replace("{{factory}}", &format!("let fixture = app.factory::<factory::{ty}Factory>(){}.create().await?;\nassert!(fixture.id > 0);", if self.auth {".with(|factory| factory.owner_id = owner_id)"} else {""}))
+ &self.default_tests()
}
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| {
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"
};
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}\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(())
}