appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
mod support;

use appstruct_codegen::{Artifact, plan};
use appstruct_compiler::compile_project;
use appstruct_ir::FileProviderIr;
use std::{fs, path::Path};
use support::{assert_rustfmt, cargo_check};

#[test]
fn file_contract_generates_compilable_local_and_s3_backends() {
    let fixture =
        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures/m6-file-project");
    let ir = compile_project(&fixture).unwrap();
    let temporary = tempfile::tempdir().unwrap();
    assert_provider(
        &ir,
        FileProviderIr::Local,
        "LocalFileSystem",
        temporary.path(),
    );
    assert_provider(&ir, FileProviderIr::S3, "AmazonS3Builder", temporary.path());
}

fn assert_provider(
    ir: &appstruct_ir::AppIr,
    provider: FileProviderIr,
    marker: &str,
    temporary: &Path,
) {
    let mut ir = ir.clone();
    ir.file.provider = provider;
    let artifacts = plan(&ir).unwrap();
    let name = match provider {
        FileProviderIr::Local => "local",
        FileProviderIr::S3 => "s3",
    };
    let root = temporary.join(name);
    write_artifacts(&root, &artifacts);

    let sql = artifact_text(&artifacts, "database/0001_initial.sql");
    assert!(sql.contains("_appstruct_files"));
    assert!(sql.contains("\"object_key\" TEXT NOT NULL UNIQUE"));
    assert!(sql.contains("FOREIGN KEY (\"tenant_id\")"));
    let file = artifact_text(&artifacts, "backend/src/file.rs");
    assert!(file.contains(marker));
    assert!(file.contains("file key must be a safe relative path"));
    assert!(file.contains("stored object checksum does not match metadata"));
    assert!(file.contains("tenant_id IS NOT DISTINCT FROM"));
    assert!(file.contains("put_with_connection<C: DatabaseExecutor>"));
    assert!(file.contains("load_metadata<C: DatabaseExecutor>"));
    let delete = &file[file.find("pub async fn delete").expect("delete handler")..];
    let metadata = delete.find("DELETE FROM").expect("metadata delete");
    let storage = delete.find("self.provider.delete").expect("storage delete");
    assert!(
        storage < metadata,
        "file delete must remove storage before metadata so failures remain retryable"
    );
    let extensions = artifact_text(&artifacts, "backend/src/extensions.rs");
    assert!(extensions.contains("pub async fn put_file"));
    assert!(extensions.contains("pub async fn get_file"));
    assert!(extensions.contains("pub async fn delete_file"));
    assert!(extensions.contains("put_with_connection("));
    assert!(extensions.contains("delete_with_connection(database"));
    let manifest = artifact_text(&artifacts, "backend/Cargo.toml");
    assert!(manifest.contains("object_store"));
    assert_eq!(
        manifest.contains("features = [\"aws\"]"),
        provider == FileProviderIr::S3
    );
    assert!(manifest.contains("infer = \"=0.22.0\""));
    let admin = artifact_text(&artifacts, "backend/src/auth/admin_storage.rs");
    assert!(admin.contains("/api/admin/files"));
    assert!(admin.contains("total_bytes"));
    let admin_pages = artifact_text(&artifacts, "web/src/auth/AdminStoragePages.tsx");
    assert!(admin_pages.contains("AdminFileDetailPage"));
    let openapi: serde_json::Value =
        serde_json::from_str(artifact_text(&artifacts, "openapi/openapi.json")).unwrap();
    assert!(openapi["paths"]["/api/admin/files"]["get"].is_object());
    assert!(openapi["paths"]["/api/admin/files/{id}"]["get"].is_object());

    let manifest = root.join("generated/backend/Cargo.toml");
    assert_rustfmt(&manifest);
    let checked = cargo_check(&manifest, true);
    assert!(
        checked.status.success(),
        "{name}: {}",
        String::from_utf8_lossy(&checked.stderr)
    );
}

fn artifact_text<'artifacts>(artifacts: &'artifacts [Artifact], path: &str) -> &'artifacts str {
    let artifact = artifacts
        .iter()
        .find(|artifact| artifact.relative_path == Path::new(path))
        .unwrap();
    std::str::from_utf8(&artifact.content).unwrap()
}

fn write_artifacts(root: &Path, artifacts: &[Artifact]) {
    for artifact in artifacts {
        let destination = root.join("generated").join(&artifact.relative_path);
        fs::create_dir_all(destination.parent().unwrap()).unwrap();
        fs::write(destination, &artifact.content).unwrap();
    }
}