appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use std::collections::hash_map::DefaultHasher;
use std::fs::{self, File, OpenOptions};
use std::hash::{Hash, Hasher};
use std::path::{Path, PathBuf};
use std::process::{Command, Output};
use std::sync::Mutex;

static CARGO_CHECK_LOCK: Mutex<()> = Mutex::new(());

#[allow(dead_code)]
pub fn cargo_test(manifest: &Path, test: &str) -> Output {
    let _guard = CARGO_CHECK_LOCK
        .lock()
        .expect("generated crate check lock is not poisoned");
    let _target_guard = GeneratedTargetLock::acquire();
    let cache_key = refresh_generated_cache();
    let _ = prepare_generated_package(manifest);
    let packages = local_packages(manifest);
    let output = Command::new("cargo")
        .args(["test", "--quiet", "--manifest-path"])
        .arg(manifest)
        .args(["--test", test])
        .env("CARGO_TARGET_DIR", generated_target())
        .env("CARGO_INCREMENTAL", "0")
        .env("RUSTFLAGS", "-Dwarnings")
        .output()
        .unwrap();
    record_generated_cache(&cache_key);
    clean_local_packages(manifest, &packages);
    output
}

pub fn cargo_check(manifest: &Path, library_only: bool) -> Output {
    cargo_check_with_features(manifest, library_only, &[])
}

pub fn cargo_check_with_features(manifest: &Path, library_only: bool, features: &[&str]) -> Output {
    let _guard = CARGO_CHECK_LOCK
        .lock()
        .expect("generated crate check lock is not poisoned");
    let _target_guard = GeneratedTargetLock::acquire();
    let cache_key = refresh_generated_cache();
    let _ = prepare_generated_package(manifest);
    let packages = local_packages(manifest);
    let mut command = Command::new("cargo");
    command
        .args(["check", "--quiet", "--manifest-path"])
        .arg(manifest)
        .env("CARGO_TARGET_DIR", generated_target())
        .env("CARGO_INCREMENTAL", "0")
        .env("RUSTFLAGS", "-Dwarnings");
    if library_only {
        command.arg("--lib");
    }
    if !features.is_empty() {
        command.args(["--features", &features.join(",")]);
    }
    let output = command.output().unwrap();
    record_generated_cache(&cache_key);
    clean_local_packages(manifest, &packages);
    output
}

pub fn prepare_generated_package(manifest: &Path) -> Option<String> {
    let source = fs::read_to_string(manifest).unwrap();
    if let Some(name) = package_name(&source, "appstruct-generated-test-") {
        return Some(name);
    }
    if !source.contains("name = \"appstruct-generated-backend\"") {
        return None;
    }
    let mut hasher = DefaultHasher::new();
    source.hash(&mut hasher);
    hash_sources(&manifest.parent().unwrap().join("src"), &mut hasher);
    let name = format!("appstruct-generated-test-{:016x}", hasher.finish());
    let source = source
        .replacen(
            "name = \"appstruct-generated-backend\"",
            &format!("name = {name:?}"),
            1,
        )
        .replacen(
            "[dependencies]",
            "[lib]\nname = \"appstruct_generated_backend\"\npath = \"src/lib.rs\"\n\n[dependencies]",
            1,
        );
    fs::write(manifest, source).unwrap();
    Some(name)
}

pub fn assert_rustfmt(manifest: &Path) {
    let output = Command::new("cargo")
        .args(["fmt", "--check", "--manifest-path"])
        .arg(manifest)
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "generated Rust is not rustfmt-clean:\n{}",
        String::from_utf8_lossy(&output.stdout)
    );
}

fn generated_target() -> PathBuf {
    Path::new(env!("CARGO_MANIFEST_DIR")).join("../../target/appstruct-generated-tests")
}

struct GeneratedTargetLock {
    file: File,
}

impl GeneratedTargetLock {
    fn acquire() -> Self {
        let target = generated_target();
        let parent = target.parent().unwrap();
        fs::create_dir_all(parent).unwrap();
        let file = OpenOptions::new()
            .create(true)
            .truncate(false)
            .read(true)
            .write(true)
            .open(parent.join(".appstruct-generated-tests.lock"))
            .unwrap();
        file.lock().unwrap();
        Self { file }
    }
}

impl Drop for GeneratedTargetLock {
    fn drop(&mut self) {
        let _ = self.file.unlock();
    }
}

fn refresh_generated_cache() -> String {
    let target = generated_target();
    let marker = target.join(".appstruct-cache-key");
    let key = generated_cache_key();
    if fs::read_to_string(&marker).is_ok_and(|stored| stored == key)
        && target.join("CACHEDIR.TAG").is_file()
    {
        return key;
    }
    if target.exists() {
        fs::remove_dir_all(&target).unwrap();
    }
    key
}

fn record_generated_cache(key: &str) {
    let target = generated_target();
    if target.join("CACHEDIR.TAG").is_file() {
        fs::write(target.join(".appstruct-cache-key"), key).unwrap();
    }
}

fn generated_cache_key() -> String {
    let mut hasher = DefaultHasher::new();
    fs::read(Path::new(env!("CARGO_MANIFEST_DIR")).join("../../Cargo.lock"))
        .unwrap()
        .hash(&mut hasher);
    Command::new("rustc")
        .args(["--version", "--verbose"])
        .output()
        .unwrap()
        .stdout
        .hash(&mut hasher);
    Command::new("cargo")
        .args(["--version", "--verbose"])
        .output()
        .unwrap()
        .stdout
        .hash(&mut hasher);
    format!("{:016x}\n", hasher.finish())
}

fn local_packages(manifest: &Path) -> Vec<String> {
    let output = Command::new("cargo")
        .args(["metadata", "--format-version", "1", "--manifest-path"])
        .arg(manifest)
        .output()
        .unwrap();
    assert!(
        output.status.success(),
        "cannot inspect generated crate packages:\n{}",
        String::from_utf8_lossy(&output.stderr)
    );
    let metadata: serde_json::Value = serde_json::from_slice(&output.stdout).unwrap();
    let mut packages = metadata["packages"]
        .as_array()
        .unwrap()
        .iter()
        .filter(|package| package["source"].is_null())
        .map(|package| package["name"].as_str().unwrap().to_owned())
        .collect::<Vec<_>>();
    packages.sort();
    packages.dedup();
    packages
}

fn clean_local_packages(manifest: &Path, packages: &[String]) {
    assert!(
        !packages.is_empty(),
        "generated crate metadata did not contain local packages"
    );
    let mut command = Command::new("cargo");
    command
        .args(["clean", "--manifest-path"])
        .arg(manifest)
        .arg("--target-dir")
        .arg(generated_target());
    for package in packages {
        command.arg("--package").arg(package);
    }
    let output = command.output().unwrap();
    assert!(
        output.status.success(),
        "cannot reclaim generated crate packages ({}):\npackages: {}\n{}{}",
        output.status,
        packages.join("\n"),
        String::from_utf8_lossy(&output.stdout),
        String::from_utf8_lossy(&output.stderr)
    );
}

fn package_name(source: &str, prefix: &str) -> Option<String> {
    source.lines().find_map(|line| {
        line.strip_prefix("name = \"")
            .and_then(|name| name.strip_suffix('"'))
            .filter(|name| name.starts_with(prefix))
            .map(str::to_owned)
    })
}

fn hash_sources(directory: &Path, hasher: &mut DefaultHasher) {
    let mut entries = fs::read_dir(directory)
        .unwrap()
        .map(|entry| entry.unwrap().path())
        .collect::<Vec<_>>();
    entries.sort();
    for path in entries {
        path.file_name().hash(hasher);
        if path.is_dir() {
            hash_sources(&path, hasher);
        } else {
            fs::read(path).unwrap().hash(hasher);
        }
    }
}

#[allow(dead_code)]
pub fn server_manifest(generated_package: &str) -> String {
    format!(
        r#"[package]
name = "appstruct-extension-server"
version = "0.0.0"
edition = "2024"

[dependencies]
appstruct-generated-backend = {{ package = {generated_package:?}, path = "../generated/backend" }}
async-trait = "0.1.92"
"#
    )
}

#[allow(dead_code)]
pub fn missing_handler_source() -> &'static str {
    r"use appstruct_generated_backend::{ApiError, AppExtensions, RequestContext};
use appstruct_generated_backend::entities::project;
use appstruct_generated_backend::extensions::{ArchiveProjectHandler, ArchiveProjectInput};
use async_trait::async_trait;

struct Handlers;

#[async_trait]
impl ArchiveProjectHandler for Handlers {
    async fn execute(&self, _ctx: &RequestContext, _input: ArchiveProjectInput) -> Result<project::Model, ApiError> {
        Err(ApiError::NotFound)
    }
}

fn main() { let _extensions = AppExtensions::builder().handlers(Handlers).build(); }
"
}

#[allow(dead_code)]
pub fn complete_handler_source() -> &'static str {
    r"use appstruct_generated_backend::{ApiError, AppExtensions, RequestContext};
use appstruct_generated_backend::entities::project;
use appstruct_generated_backend::extensions::{ArchiveProjectHandler, ArchiveProjectInput, ProjectMetrics, ProjectMetricsHandler};
use async_trait::async_trait;

struct Handlers;

#[async_trait]
impl ArchiveProjectHandler for Handlers {
    async fn execute(&self, _ctx: &RequestContext, _input: ArchiveProjectInput) -> Result<project::Model, ApiError> {
        Err(ApiError::NotFound)
    }
}

#[async_trait]
impl ProjectMetricsHandler for Handlers {
    async fn execute(&self, _ctx: &RequestContext) -> Result<ProjectMetrics, ApiError> {
        Ok(ProjectMetrics { active: 0, total: 0 })
    }
}

fn main() { let _extensions = AppExtensions::builder().handlers(Handlers).build(); }
"
}