use super::{field::Kind, Resource};
use crate::{edit::EditPlan, FrontendDriver, ProjectConfig};
use anyhow::{bail, Result};
use heck::ToTitleCase;
use std::path::Path;
impl Resource {
pub(super) fn frontend(&self, root: &Path, plan: &mut EditPlan<'_>) -> Result<()> {
if ProjectConfig::load(root)?.frontend.driver != FrontendDriver::React {
bail!("--frontend requires a Capy React application. No files changed.");
}
if self.auth && !plan.exists("frontend/src/features/auth/AuthProvider.tsx") {
bail!("Install the browser auth pages with capy make:auth --frontend before generating an authenticated React resource. No files changed.");
}
let table = self.table();
let ty = &self.names.ty;
let label = self.names.module.to_title_case();
let directory = format!("frontend/src/features/{table}");
let render = |template: &str| {
self.render(template)
.replace("{{label}}", &label)
.replace("{{plural-label}}", &table.to_title_case())
};
plan.create(&format!("{directory}/api.ts"), render(r#"import { api } from '../../lib/api'
import type { Create{{type}}Request, Update{{type}}Request } from '../../generated/api-types'
export const {{table}} = {
list: (page = 1, signal?: AbortSignal) => api.get('/api/{{table}}', { params: { query: { page, per_page: 20 } }, signal }),
show: (id: number, signal?: AbortSignal) => api.get('/api/{{table}}/{id}', { params: { path: { id } }, signal }),
create: (body: Create{{type}}Request) => api.post('/api/{{table}}', { body }),
update: (id: number, body: Update{{type}}Request) => api.put('/api/{{table}}/{id}', { params: { path: { id } }, body }),
delete: (id: number) => api.delete('/api/{{table}}/{id}', { params: { path: { id } } }),
}
"#))?;
plan.create(&format!("{directory}/hooks.ts"), render(r#"import { useCallback } from 'react'
import { useApiQuery, useApiMutation } from '../../lib/useApi'
import { {{table}} } from './api'
export const use{{plural-type}} = (page = 1) => useApiQuery(useCallback((signal: AbortSignal) => {{table}}.list(page, signal), [page]))
export const use{{type}} = (id: number) => useApiQuery(useCallback((signal: AbortSignal) => {{table}}.show(id, signal), [id]))
export const useCreate{{type}} = () => useApiMutation({{table}}.create)
export const useUpdate{{type}} = () => useApiMutation({{table}}.update)
export const useDelete{{type}} = () => useApiMutation({{table}}.delete)
"#))?;
let mut inputs = String::new();
let mut values = String::new();
for field in &self.fields {
let name = &field.name;
let label = name.to_title_case();
let required = if field.nullable { "" } else { " required" };
let default = field
.default
.as_deref()
.filter(|value| *value != "null")
.unwrap_or("");
let default = serde_json::to_string(default)?;
let mut value = format!("String(data.get('{name}') ?? '')");
let initial = format!("initial ? (initial.{name} ?? '') : {default}");
let input = match field.kind {
Kind::Boolean if !field.nullable => {
value = format!("data.get('{name}') === 'on'");
format!("<input name=\"{name}\" type=\"checkbox\" defaultChecked={{initial?.{name} ?? {}}} />", field.default.as_deref().unwrap_or("false"))
}
Kind::Boolean => {
value = format!("data.get('{name}') === 'true'");
format!("<select name=\"{name}\" defaultValue={{initial ? (initial.{name} == null ? '' : String(initial.{name})) : {default}}}><option value=\"\">Not set</option><option value=\"true\">Yes</option><option value=\"false\">No</option></select>")
}
Kind::Text => format!("<textarea name=\"{name}\" defaultValue={{{initial}}} maxLength={{50000}}{required} />"),
Kind::Integer | Kind::Float => {
value = format!("Number(data.get('{name}'))");
format!("<input name=\"{name}\" type=\"number\" step=\"{}\"{} defaultValue={{{initial}}}{required} />", if field.kind == Kind::Integer {"1"} else {"any"}, if field.kind == Kind::Integer {" min={-2147483648} max={2147483647}"} else {""})
}
Kind::Bigint => format!("<input name=\"{name}\" inputMode=\"numeric\" pattern=\"-?[0-9]+\" defaultValue={{{initial}}}{required} />"),
Kind::Date => format!("<input name=\"{name}\" type=\"date\" defaultValue={{{initial}}}{required} />"),
Kind::Datetime => format!("<input name=\"{name}\" placeholder=\"2026-01-01T12:00:00Z\" defaultValue={{{initial}}}{required} /><small>RFC3339 date and time, including timezone.</small>"),
Kind::Uuid => format!("<input name=\"{name}\" pattern=\"[0-9a-fA-F]{{8}}-[0-9a-fA-F]{{4}}-[0-9a-fA-F]{{4}}-[0-9a-fA-F]{{4}}-[0-9a-fA-F]{{12}}\" defaultValue={{{initial}}}{required} />"),
Kind::String => format!("<input name=\"{name}\" maxLength={{255}} defaultValue={{{initial}}}{required} />"),
Kind::Decimal => format!("<input name=\"{name}\" inputMode=\"decimal\" pattern=\"{}\" defaultValue={{{initial}}}{required} />", field.decimal_pattern()),
Kind::Enum => {
let variants = field.enum_values.as_ref().expect("parsed enum");
let options = variants.iter().map(|value| format!("<option value=\"{value}\">{value}</option>")).collect::<Vec<_>>().join("");
let allowed = variants.iter().map(|value| format!("{value:?}")).collect::<Vec<_>>().join(", ");
value = format!("(() => {{ const selected = String(data.get('{name}') ?? ''); if (![{allowed}].includes(selected)) throw new Error('Invalid {name}'); return selected as Update{}Request['{name}'] }})()", self.names.ty);
format!("<select name=\"{name}\" defaultValue={{{initial}}}{required}>{}{options}</select>", if field.nullable {"<option value=\"\">Not set</option>"} else {""})
}
};
if field.nullable {
value = format!("data.get('{name}') === '' ? null : {value}");
}
values.push_str(&format!("{name}: {value},\n"));
inputs.push_str(&format!("<label>{label}{input}</label>\n"));
}
plan.create(
&format!("{directory}/components/{ty}Form.tsx"),
render(include_str!("../../templates/resource/form.tsx.txt"))
.replace("{{form-values}}", &values)
.replace("{{form-fields}}", &inputs),
)?;
let headings = self
.fields
.iter()
.take(3)
.map(|field| format!("<th>{}</th>", field.name.to_title_case()))
.collect::<Vec<_>>()
.join("");
let columns = self
.fields
.iter()
.take(3)
.map(|field| {
format!(
"<td>{{String(row.{} ?? '—').slice(0, 120)}}</td>",
field.name
)
})
.collect::<Vec<_>>()
.join("\n");
let details = self
.fields
.iter()
.map(|field| {
format!(
"<dt>{}</dt><dd>{{String(data.{} ?? '—')}}</dd>",
field.name.to_title_case(),
field.name
)
})
.collect::<Vec<_>>()
.join("\n");
for (page, template) in [
(
"List",
include_str!("../../templates/resource/list.tsx.txt"),
),
(
"Detail",
include_str!("../../templates/resource/detail.tsx.txt"),
),
(
"Create",
include_str!("../../templates/resource/create.tsx.txt"),
),
(
"Edit",
include_str!("../../templates/resource/edit.tsx.txt"),
),
] {
plan.create(
&format!("{directory}/pages/{ty}{page}.tsx"),
render(template)
.replace("{{table-headings}}", &headings)
.replace("{{table-values}}", &columns)
.replace("{{detail-values}}", &details)
.replace(
"{{auth-import}}",
if self.public_read && matches!(page, "List" | "Detail") {
"import { useAuth } from '../../auth/AuthProvider'"
} else {
""
},
)
.replace(
"{{auth-state}}",
if self.public_read && matches!(page, "List" | "Detail") {
"const { user } = useAuth()"
} else {
""
},
)
.replace(
"{{create-link}}",
&render(if self.public_read {
"{user && <a href=\"/{{table}}/new\">Create {{label}}</a>}"
} else {
"<a href=\"/{{table}}/new\">Create {{label}}</a>"
}),
)
.replace(
"{{edit-link}}",
&render(match (self.public_read, page) {
(true, "List") => {
"{user && <a href={`/{{table}}/${row.id}/edit`}>Edit</a>}"
}
(true, _) => "{user && <a href={`/{{table}}/${id}/edit`}>Edit</a>}",
(false, "List") => "<a href={`/{{table}}/${row.id}/edit`}>Edit</a>",
(false, _) => "<a href={`/{{table}}/${id}/edit`}>Edit</a>",
}),
)
.replace(
"{{delete-button}}",
if self.public_read {
"{user && <button onClick={() => setConfirm(true)}>Delete</button>}"
} else {
"<button onClick={() => setConfirm(true)}>Delete</button>"
},
)
.replace(
"{{confirm-condition}}",
if self.public_read {
"{user && confirm && "
} else {
"{confirm && "
},
),
)?;
}
let mut routes = "import type { FeatureRoute } from '../../lib/router'\n".to_owned();
if self.auth {
routes.push_str("import { ProtectedRoute } from '../auth/AuthProvider'\n");
}
for page in ["List", "Create", "Detail", "Edit"] {
routes.push_str(&format!(
"import {{ {ty}{page} }} from './pages/{ty}{page}'\n"
));
}
routes.push_str(&format!(
"\nexport const {table}Routes: FeatureRoute[] = [\n"
));
for (path, page, param) in [
(format!("/{table}"), "List", false),
(format!("/{table}/new"), "Create", false),
(format!("/{table}/:id/edit"), "Edit", true),
(format!("/{table}/:id"), "Detail", true),
] {
let component = format!(
"<{ty}{page}{} />",
if param { " id={Number(params.id)}" } else { "" }
);
let content = if self.auth && !(self.public_read && matches!(page, "List" | "Detail")) {
format!("<ProtectedRoute>{component}</ProtectedRoute>")
} else {
component
};
let content = if param {
format!("Number.isSafeInteger(Number(params.id)) && Number(params.id) > 0 ? {content} : <main className=\"feature\">Invalid resource ID</main>")
} else {
content
};
routes.push_str(&format!(
" {{ path: '{path}', {}render: ({}) => {content} }},\n",
if page == "List" {
format!("label: '{}', ", table.to_title_case())
} else {
String::new()
},
if param { "params" } else { "" }
));
}
routes.push_str("]\n");
plan.create(&format!("{directory}/index.tsx"), routes)?;
plan.anchor(
"frontend/src/features/index.ts",
"// capy:feature-imports",
&format!("import {{ {table}Routes }} from './{table}'"),
)?;
plan.anchor(
"frontend/src/features/index.ts",
"// capy:feature-routes",
&format!("...{table}Routes,"),
)?;
Ok(())
}
}