appstruct-codegen 0.1.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use std::collections::hash_map::DefaultHasher;
use std::fs;
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(());

pub fn cargo_check(manifest: &Path, library_only: bool) -> Output {
    let _guard = CARGO_CHECK_LOCK
        .lock()
        .expect("generated crate check lock is not poisoned");
    let _ = prepare_generated_package(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");
    }
    command.output().unwrap()
}

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")
}

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.89"
"#
    )
}

#[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(); }
"
}