capy-cli 0.9.0

The command-line interface for the Capy web framework.
Documentation
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} />"),
            };
            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),
            )?;
        }
        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 {
                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(())
    }
}