appstruct-cli 0.2.0

Command-line compiler and development workflow for AppStruct applications
use appstruct_migrate::{connect_database, extract, initial_migration};
use serde_json::Value;
use std::fs;
use std::process::{Command, Output};

fn project() -> tempfile::TempDir {
    let project = tempfile::tempdir().unwrap();
    fs::write(project.path().join("appstruct.yaml"), "version: 1\napp: { name: baseline-demo }\ndatabase: { provider: postgres }\nincludes: [domain.yaml]\n").unwrap();
    fs::write(
        project.path().join("domain.yaml"),
        r"domain: core
entities:
  Note:
    fields:
      id: { type: uuid, primary_key: true }
      title: { type: string, required: true }
    access:
      list: { public: true }
      read: { public: true }
      create: { public: true }
      update: { public: true }
      delete: { public: true }
",
    )
    .unwrap();
    project
}

fn run(project: &std::path::Path, args: &[&str]) -> Output {
    Command::new(env!("CARGO_BIN_EXE_appstruct"))
        .arg("--project")
        .arg(project)
        .args(args)
        .args(["--format", "json"])
        .env_remove("DATABASE_URL")
        .output()
        .unwrap()
}

#[test]
fn baseline_requires_database_configuration_and_does_not_write_files() {
    let project = project();
    let output = run(project.path(), &["migrate", "baseline"]);
    assert_eq!(output.status.code(), Some(3));
    let report: Value = serde_json::from_slice(&output.stdout).unwrap();
    assert_eq!(report["ok"], false);
    assert!(!project.path().join("migrations").exists());
    assert!(!project.path().join(".appstruct").exists());
}

#[test]
fn baseline_cli_previews_and_registers_using_project_dotenv() {
    let Ok(url) = std::env::var("APPSTRUCT_E2E_DATABASE_URL") else {
        return;
    };
    let schema_name = format!("baseline_cli_{}", std::process::id());
    let mut client = connect_database(&url).unwrap();
    client
        .batch_execute(&format!(
            "CREATE SCHEMA {schema_name}; SET search_path TO {schema_name}"
        ))
        .unwrap();
    let guard = SchemaGuard {
        client,
        schema: schema_name.clone(),
    };
    let project = project();
    let ir = appstruct_compiler::compile_project(project.path()).unwrap();
    let schema = extract(&ir).unwrap();
    let mut guard = guard;
    guard
        .client
        .batch_execute(&initial_migration(&schema))
        .unwrap();
    guard.client.batch_execute("INSERT INTO notes (id, title) VALUES ('00000000-0000-4000-8000-000000000001', 'keep me')").unwrap();
    let separator = if url.contains('?') { '&' } else { '?' };
    fs::write(
        project.path().join(".env"),
        format!("DATABASE_URL='{url}{separator}options=-csearch_path%3D{schema_name}'\n"),
    )
    .unwrap();

    let preview = run(project.path(), &["migrate", "baseline"]);
    assert!(
        preview.status.success(),
        "{}",
        String::from_utf8_lossy(&preview.stdout)
    );
    let report: Value = serde_json::from_slice(&preview.stdout).unwrap();
    assert_eq!(report["result"]["registered"], false);
    assert_eq!(report["result"]["accepted"], false);
    assert!(!project.path().join("migrations").exists());
    assert!(!project.path().join(".appstruct").exists());
    for _ in 0..2 {
        let output = run(project.path(), &["migrate", "baseline", "--accept"]);
        assert!(
            output.status.success(),
            "{}",
            String::from_utf8_lossy(&output.stdout)
        );
        let report: Value = serde_json::from_slice(&output.stdout).unwrap();
        assert_eq!(report["result"]["registered"], true);
    }
    assert_eq!(
        fs::read_dir(project.path().join("migrations"))
            .unwrap()
            .count(),
        1
    );
    let status = run(project.path(), &["migrate", "status"]);
    assert!(
        status.status.success(),
        "{}",
        String::from_utf8_lossy(&status.stdout)
    );
    let report: Value = serde_json::from_slice(&status.stdout).unwrap();
    assert_eq!(report["result"]["applied"], 1);
    assert_eq!(report["result"]["pending"], 0);
    assert_eq!(
        guard
            .client
            .query_one("SELECT title FROM notes", &[])
            .unwrap()
            .get::<_, String>(0),
        "keep me"
    );
}

struct SchemaGuard {
    client: postgres::Client,
    schema: String,
}

impl Drop for SchemaGuard {
    fn drop(&mut self) {
        let _ = self
            .client
            .batch_execute(&format!("DROP SCHEMA {} CASCADE", self.schema));
    }
}