capy-cli 0.7.2

The command-line interface for the Capy web framework.
Documentation
use crate::{generate::format_rust, names::GeneratedNames, Generator};
use anyhow::{bail, Context, Result};
use fs2::FileExt;
use std::{
    fs::{self, OpenOptions},
    io::Write,
    path::{Path, PathBuf},
    time::{SystemTime, UNIX_EPOCH},
};

struct Change {
    path: PathBuf,
    before: Option<Vec<u8>>,
    after: Vec<u8>,
}

/// Generate a job with explicit registration. First use installs the optional feature,
/// application hook and native migration. Writes are locked, formatted and rolled back
/// on failure; application files are never silently replaced.
pub fn make_job(root: &Path, name: &str) -> Result<Vec<PathBuf>> {
    make_job_with(root, name, |file, path, existing| {
        if existing {
            file.persist(path).map(|_| ()).map_err(|e| e.error.into())
        } else {
            file.persist_noclobber(path)
                .map(|_| ())
                .map_err(|e| e.error.into())
        }
    })
}
fn make_job_with(
    root: &Path,
    name: &str,
    mut persist: impl FnMut(tempfile::NamedTempFile, &Path, bool) -> Result<()>,
) -> Result<Vec<PathBuf>> {
    let names = GeneratedNames::new(name)?;
    reject_symlinks(root, &root.join(".capy-generator.lock"))?;
    let lock = OpenOptions::new()
        .read(true)
        .write(true)
        .create(true)
        .truncate(false)
        .open(root.join(".capy-generator.lock"))?;
    lock.lock_exclusive()
        .context("Cannot lock the Capy generator registry")?;
    let first = !root.join("app/jobs/mod.rs").exists();
    let mut registry = if first {
        include_str!("../templates/jobs.rs.txt").to_owned()
    } else {
        read(root, "app/jobs/mod.rs")?
    };
    names.check_registry(&registry, &names.module, Generator::Controller)?;
    if registry.matches("// capy:modules").count() != 1
        || registry.matches("// capy:jobs").count() != 1
    {
        bail!("Restore // capy:modules and // capy:jobs in app/jobs/mod.rs before generating; no files changed.");
    }
    registry = registry
        .replace(
            "// capy:modules",
            &format!("pub mod {};\n// capy:modules", names.module),
        )
        .replace(
            "// capy:jobs",
            &format!(
                ".register::<{}::{}>()\n// capy:jobs",
                names.module, names.ty
            ),
        );
    let mut changes = Vec::new();
    let mut add = |relative: &str, after: String, existing: bool| -> Result<()> {
        let path = root.join(relative);
        reject_symlinks(root, &path)?;
        let before = match fs::read(&path) {
            Ok(bytes) => Some(bytes),
            Err(e) if e.kind() == std::io::ErrorKind::NotFound => None,
            Err(e) => return Err(e.into()),
        };
        if before.is_some() != existing {
            bail!(
                "{} {}. Capy never overwrites generated code.",
                path.display(),
                if existing {
                    "is missing"
                } else {
                    "already exists"
                }
            );
        }
        let after = if relative.ends_with(".rs") {
            format_rust(&after)?
        } else {
            after
        };
        changes.push(Change {
            path,
            before,
            after: after.into_bytes(),
        });
        Ok(())
    };
    add(
        &format!("app/jobs/{}.rs", names.module),
        include_str!("../templates/job.rs.txt")
            .replace("{{name}}", &names.module)
            .replace("{{type}}", &names.ty),
        false,
    )?;
    add("app/jobs/mod.rs", registry, !first)?;
    if first {
        let app = read(root, "app/mod.rs")?;
        GeneratedNames::new("Jobs")?.check_registry(&app, "jobs", Generator::Controller)?;
        add("app/mod.rs", format!("{app}\npub mod jobs;\n"), true)?;
        let main = read(root, "src/main.rs")?;
        if main.matches("App::new()").count() != 1
            || !main.contains("as application;")
            || main.contains(".jobs(")
        {
            bail!("Job installation needs the conventional App::new() builder and application alias in src/main.rs. Install jobs manually for a customized entry point; no files changed.");
        }
        add(
            "src/main.rs",
            main.replace(
                "App::new()",
                "App::new().jobs(application::app::jobs::jobs())",
            ),
            true,
        )?;
        let mut manifest = read(root, "Cargo.toml")?.parse::<toml_edit::DocumentMut>()?;
        let dependency = manifest["dependencies"]["capy"]
            .as_table_like_mut()
            .context("Use a table-style capy-framework dependency before installing jobs.")?;
        let mut features = dependency
            .get("features")
            .and_then(|v| v.as_array())
            .cloned()
            .unwrap_or_default();
        if !features.iter().any(|v| v.as_str() == Some("jobs")) {
            features.push("jobs");
        }
        dependency.insert("features", toml_edit::value(features));
        add("Cargo.toml", manifest.to_string(), true)?;
        add("config/jobs.toml", "# Separate worker: capy queue:work. SQLite requires concurrency = 1.\nconcurrency = 1\npoll_interval_ms = 1000\nlease_seconds = 60\nshutdown_timeout_seconds = 30\n".into(), false)?;
        let migration = format!(
            "m{}_create_jobs",
            SystemTime::now().duration_since(UNIX_EPOCH)?.as_nanos()
        );
        add(&format!("database/migrations/{migration}.rs"), "//! Durable queue schema, applied explicitly by capy migrate.\npub use capy::jobs::migration::JobsMigration as Migration;\n".into(), false)?;
        let migrations = read(root, "database/migrations/mod.rs")?;
        if migrations.matches("// capy:modules").count() != 1
            || migrations.matches("// capy:migrations").count() != 1
        {
            bail!(
                "Restore the migration registry markers before installing jobs; no files changed."
            );
        }
        add(
            "database/migrations/mod.rs",
            migrations
                .replace(
                    "// capy:modules",
                    &format!("mod {migration};\n// capy:modules"),
                )
                .replace(
                    "// capy:migrations",
                    &format!("Box::new({migration}::Migration),\n// capy:migrations"),
                ),
            true,
        )?;
    }
    // All validation/formatting completes before filesystem mutation. Stage on the
    // same filesystem, then create the sole optional directory under app/.
    let mut staged = Vec::new();
    for change in &changes {
        let mut file = tempfile::NamedTempFile::new_in(root)?;
        if change.before.is_some() {
            file.as_file()
                .set_permissions(fs::metadata(&change.path)?.permissions())?;
        }
        file.write_all(&change.after)?;
        file.as_file().sync_all()?;
        staged.push(file);
    }
    let directory = root.join("app/jobs");
    let created_directory = !directory.exists();
    if created_directory {
        fs::create_dir(&directory)?;
    }
    for (index, (file, change)) in staged.into_iter().zip(&changes).enumerate() {
        if let Err(error) = persist(file, &change.path, change.before.is_some()) {
            for previous in changes[..index].iter().rev() {
                if let Some(bytes) = &previous.before {
                    let mut restored = tempfile::NamedTempFile::new_in(root)?;
                    restored
                        .as_file()
                        .set_permissions(fs::metadata(&previous.path)?.permissions())?;
                    restored.write_all(bytes)?;
                    restored.as_file().sync_all()?;
                    restored
                        .persist(&previous.path)
                        .map_err(|e| e.error)
                        .context(
                            "Job generator rollback failed; inspect partially installed files",
                        )?;
                } else {
                    fs::remove_file(&previous.path)?;
                }
            }
            if created_directory {
                fs::remove_dir(&directory)?;
            }
            return Err(error.context("Job generation failed; committed changes were rolled back"));
        }
    }
    Ok(changes.into_iter().map(|c| c.path).collect())
}
fn read(root: &Path, relative: &str) -> Result<String> {
    let path = root.join(relative);
    reject_symlinks(root, &path)?;
    fs::read_to_string(&path).with_context(|| format!("Cannot read {}", path.display()))
}
fn reject_symlinks(root: &Path, path: &Path) -> Result<()> {
    for ancestor in path.ancestors().take_while(|p| *p != root) {
        if let Ok(metadata) = fs::symlink_metadata(ancestor) {
            if metadata.file_type().is_symlink() {
                bail!("Job generator refuses symlink {}", ancestor.display());
            }
        }
    }
    Ok(())
}

#[cfg(test)]
mod tests {
    use super::*;
    #[test]
    fn failed_install_restores_original_files_and_removes_directory() {
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path().join("app");
        crate::new_project_with_frontend(&root, "app", crate::FrontendDriver::None).unwrap();
        let before = fs::read(root.join("app/mod.rs")).unwrap();
        let mut writes = 0;
        let result = make_job_with(&root, "SendWelcome", |file, path, _| {
            writes += 1;
            if writes == 5 {
                bail!("simulated write failure");
            }
            file.persist(path).map(|_| ()).map_err(|e| e.error.into())
        });
        assert!(format!("{:#}", result.unwrap_err()).contains("rolled back"));
        assert_eq!(fs::read(root.join("app/mod.rs")).unwrap(), before);
        assert!(!root.join("app/jobs").exists());
        assert!(!fs::read_to_string(root.join("src/main.rs"))
            .unwrap()
            .contains(".jobs("));
    }
    #[test]
    fn repeated_generation_registers_once_and_rejects_collisions() {
        let temp = tempfile::tempdir().unwrap();
        let root = temp.path().join("app");
        crate::new_project_with_frontend(&root, "app", crate::FrontendDriver::None).unwrap();
        make_job(&root, "SendWelcome").unwrap();
        make_job(&root, "GenerateReport").unwrap();
        let before = fs::read(root.join("app/jobs/mod.rs")).unwrap();
        assert!(make_job(&root, "SendWelcome").is_err());
        assert!(make_job(&root, "Jobs").is_err());
        assert_eq!(fs::read(root.join("app/jobs/mod.rs")).unwrap(), before);
        assert_eq!(
            fs::read_to_string(root.join("src/main.rs"))
                .unwrap()
                .matches(".jobs(")
                .count(),
            1
        );
    }
}