appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::support::{assert_rustfmt, cargo_check};
use super::{artifact_text, write_artifacts};
use appstruct_codegen::{Artifact, plan};
use appstruct_compiler::compile_project;
use serde_json::Value;
use std::path::Path;

#[test]
fn relation_filter_applies_target_access_and_tenant_scope() {
    let fixture =
        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures/m6-tenant-project");
    let mut ir = compile_project(&fixture).unwrap();
    let project = ir
        .entities
        .iter_mut()
        .find(|entity| entity.rust_name == "Project")
        .unwrap();
    project
        .fields
        .iter_mut()
        .find(|field| field.rust_name == "name")
        .unwrap()
        .capabilities
        .filterable = true;
    let task = ir
        .entities
        .iter_mut()
        .find(|entity| entity.rust_name == "Task")
        .unwrap();
    task.fields
        .iter_mut()
        .find(|field| field.rust_name == "project_id")
        .unwrap()
        .capabilities
        .filterable = true;

    let artifacts = plan(&ir).unwrap();
    let api = artifact_text(&artifacts, "backend/src/api/task.rs");
    let related = &api[api.find("filter[project.name]").unwrap()..];
    assert!(related.contains("let relation_access_scope = context.actor()"));
    assert!(related.contains("project::Column::TenantId.eq(context.require_tenant()?)"));
    assert!(related.contains("project::Column::Name.eq(value)"));
    let aggregate = &api[api.find("async fn aggregate").unwrap()..];
    assert!(aggregate.contains("\"project.name\""));
    assert!(aggregate.contains("task::TABLE"));
    assert!(aggregate.contains("project::Column::TenantId.eq(context.require_tenant()?)"));
    assert!(aggregate.contains("group_project_name"));
}

pub(super) fn assert_query_contract(artifacts: &[Artifact]) {
    let client = artifact_text(artifacts, "web/src/generated/client.ts");
    assert!(client.contains("ListResponse"));
    assert!(client.contains("CursorListResponse"));
    assert!(client.contains("ListResponse<Partial<Project>>"));
    assert!(client.contains("CursorListResponse<Partial<Project>>"));
    assert!(client.contains("listCursor"));
    assert!(client.contains("{ limit: 25, ...query }"));
    assert!(client.contains("direction?: \"next\" | \"previous\""));
    assert!(client.contains("previous_cursor: string | null"));
    assert!(client.contains("AggregateQuery"));
    assert!(client.contains("AggregateResponse"));
    assert!(client.contains("aggregatePath"));
    assert!(client.contains("aggregate: (query: AggregateQuery"));
    assert!(client.contains("range_filters"));
    assert!(client.contains("order?: \"asc\" | \"desc\""));
    assert!(client.contains("params.set(\"order\", query.order)"));

    let project_api = artifact_text(artifacts, "backend/src/api/project.rs");
    assert!(project_api.contains("cursor pagination cannot be combined"));
    assert!(project_api.contains("like_contains_pattern"));
    assert!(project_api.contains("search_term_is_valid"));
    assert!(project_api.contains("MAX_SEARCH_CHARS"));
    assert!(project_api.contains("LikeExpr::new(pattern.clone())"));
    assert!(project_api.contains("list_page_is_valid"));
    assert!(project_api.contains("MAX_LIST_PAGE"));
    let resource_runtime = artifact_text(artifacts, "backend/core/src/resource.rs");
    assert!(resource_runtime.contains("URL_SAFE_NO_PAD"));
    assert!(project_api.contains("decode::<project::Model>"));
    assert!(project_api.contains("limit + 1"));
    assert!(project_api.contains("ListMeta::Cursor"));
    assert!(project_api.contains("order_by(&order, &project::Model::META, previous)"));
    assert!(project_api.contains("previous_cursor"));
    let task_api = artifact_text(artifacts, "backend/src/api/task.rs");
    assert!(task_api.contains("filter[project.status]"));
    assert!(task_api.contains("project::Column::Status.eq(value)"));
    assert!(task_api.contains("in_subquery(relation_select.into_query())"));
    assert!(task_api.contains("async fn aggregate"));
    assert!(task_api.contains("Column::Priority.sum()"));
    assert!(task_api.contains("Column::Priority.avg()"));
    assert!(task_api.contains("Column::Priority.min()"));
    assert!(task_api.contains("Column::Priority.max()"));
    assert!(task_api.contains("group_priority"));
    assert!(task_api.contains("group_project_status"));
    assert!(task_api.contains("task::TABLE"));
    assert!(task_api.contains("at most one relation group field is allowed"));
    assert!(task_api.contains("order_by_desc(task::Column::Id.count())"));
    assert!(task_api.contains("order_by_desc(task::Column::Priority.sum())"));
    assert!(task_api.contains("limit` must be between 1 and 500"));
    assert!(task_api.contains("order` must be `asc` or `desc"));
    assert!(task_api.contains("aggregate metric `{metric}` is not allowed"));

    let openapi: Value =
        serde_json::from_str(artifact_text(artifacts, "openapi/openapi.json")).unwrap();
    let meta = &openapi["components"]["schemas"]["ProjectListResponse"]["properties"]["meta"];
    let item =
        &openapi["components"]["schemas"]["ProjectListResponse"]["properties"]["data"]["items"];
    assert_eq!(item["required"], serde_json::json!([]));
    assert!(item["properties"]["id"].is_object());
    assert_eq!(meta["type"], "object");
    assert_eq!(meta["oneOf"].as_array().unwrap().len(), 2);
    let task_parameters = openapi["paths"]["/api/tasks/"]["get"]["parameters"]
        .as_array()
        .unwrap();
    for name in ["cursor", "direction", "limit", "filter[project.status]"] {
        assert!(
            task_parameters
                .iter()
                .any(|parameter| parameter["name"] == name),
            "missing query parameter {name}"
        );
    }
    let search_parameter = task_parameters
        .iter()
        .find(|parameter| parameter["name"] == "q")
        .expect("search query parameter");
    assert_eq!(search_parameter["schema"]["maxLength"], 200);
    assert!(
        !task_parameters
            .iter()
            .any(|parameter| parameter["name"] == "filter[project.name]")
    );
    assert!(openapi["paths"]["/api/tasks/_aggregate"]["get"].is_object());
    assert!(openapi["components"]["schemas"]["TaskAggregateResponse"].is_object());
    assert!(
        openapi["paths"]["/api/tasks/_aggregate"]["get"]["parameters"]
            .as_array()
            .unwrap()
            .iter()
            .any(|parameter| parameter["name"] == "metrics")
    );
    assert!(
        openapi["paths"]["/api/tasks/_aggregate"]["get"]["parameters"]
            .as_array()
            .unwrap()
            .iter()
            .any(|parameter| parameter["name"] == "order")
    );
    assert_eq!(
        openapi["components"]["schemas"]["TaskAggregateResponse"]["properties"]["meta"]["properties"]
            ["order"]["enum"][1],
        "desc"
    );
}

#[test]
fn field_access_is_enforced_and_published_to_contracts() {
    let fixture = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures/m0-project");
    let mut ir = appstruct_compiler::compile_project(&fixture).unwrap();
    let project = ir
        .entities
        .iter_mut()
        .find(|entity| entity.rust_name == "Project")
        .unwrap();
    let secret = project
        .fields
        .iter_mut()
        .find(|field| field.rust_name == "status")
        .unwrap();
    secret.read_access = Some(appstruct_ir::AccessRuleIr::Role {
        role: "admin".to_owned(),
    });
    secret.write_access = Some(appstruct_ir::AccessRuleIr::Role {
        role: "admin".to_owned(),
    });
    let artifacts = appstruct_codegen::plan(&ir).unwrap();
    let api = artifact_text(&artifacts, "backend/src/api/project.rs");
    assert!(api.contains("fn field_read_allowed"));
    assert!(api.contains("field_write_allowed"));
    assert!(api.contains("redact_model"));
    assert!(api.contains("authorize_create_fields"));
    assert!(api.contains("actor.has_role(\"admin\")"));
    assert!(api.contains("field_read_allowed(&context, field)"));
    assert!(api.contains("row.json(&fields)"));
    assert!(
        api.split_whitespace()
            .collect::<String>()
            .contains("object.get(field).map(csv_cell)")
    );
    assert!(!api.contains("trim_matches('\\\"')"));

    let client = artifact_text(&artifacts, "web/src/generated/client.ts");
    assert!(client.contains("status?: string"));
    let resources = artifact_text(&artifacts, "web/src/generated/resources.ts");
    assert!(resources.contains("readAccess: {\"mode\":\"role\",\"role\":\"admin\"}"));
    assert!(resources.contains("writeAccess: {\"mode\":\"role\",\"role\":\"admin\"}"));
    let web_resource = artifact_text(&artifacts, "web/src/resource.ts");
    assert!(web_resource.contains("readAccess?: AccessRule"));
    assert!(web_resource.contains("writeAccess?: AccessRule"));

    let openapi: Value =
        serde_json::from_str(artifact_text(&artifacts, "openapi/openapi.json")).unwrap();
    let status = &openapi["components"]["schemas"]["Project"]["properties"]["status"];
    assert_eq!(status["x-appstruct-read-access"]["mode"], "role");
    assert_eq!(status["x-appstruct-write-access"]["role"], "admin");

    let temporary = tempfile::tempdir().unwrap();
    write_artifacts(temporary.path(), &artifacts);
    let manifest = temporary.path().join("generated/backend/Cargo.toml");
    assert_rustfmt(&manifest);
    let checked = cargo_check(&manifest, true);
    assert!(
        checked.status.success(),
        "{}",
        String::from_utf8_lossy(&checked.stderr)
    );
}

#[test]
fn bulk_mutations_use_read_access_scope_and_fallible_ids() {
    let fixture = Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures/m2-project");
    let mut ir = appstruct_compiler::compile_project(&fixture).unwrap();
    let project = ir
        .entities
        .iter_mut()
        .find(|entity| entity.rust_name == "Project")
        .unwrap();
    project.access.list = appstruct_ir::AccessRuleIr::Public;
    project.access.read = appstruct_ir::AccessRuleIr::Role {
        role: "bulk_reader".to_owned(),
    };

    let artifacts = appstruct_codegen::plan(&ir).unwrap();
    let api = artifact_text(&artifacts, "backend/src/api/project.rs");
    let update = &api[api.find("async fn bulk_update").unwrap()..];
    let update = &update[..update.find("async fn bulk_delete").unwrap()];
    assert!(update.contains("actor.has_role(\"bulk_reader\")"));
    assert!(update.contains("Uuid::parse_str(id_text)"));
    assert!(update.contains("error.into_bulk_failure(id_text)"));
    assert!(update.contains("let savepoint = transaction.begin().await?"));
    assert!(update.contains("savepoint.rollback().await?"));
    assert!(update.contains("before_validate_update(&context, &mut input.patch)"));
}

#[test]
fn tenant_soft_delete_openapi_requires_tenant_for_trash_and_restore() {
    let fixture =
        Path::new(env!("CARGO_MANIFEST_DIR")).join("../../tests/fixtures/m6-tenant-project");
    let mut ir = appstruct_compiler::compile_project(&fixture).unwrap();
    ir.entities
        .iter_mut()
        .find(|entity| entity.rust_name == "Project")
        .unwrap()
        .views
        .soft_delete = true;

    let artifacts = appstruct_codegen::plan(&ir).unwrap();
    let openapi: Value =
        serde_json::from_str(artifact_text(&artifacts, "openapi/openapi.json")).unwrap();
    for (path, method) in [
        ("/api/projects/_trash", "get"),
        ("/api/projects/_restore", "post"),
    ] {
        assert!(
            openapi["paths"][path][method]["parameters"]
                .as_array()
                .unwrap()
                .iter()
                .any(|parameter| parameter["name"] == "X-AppStruct-Tenant"
                    && parameter["required"] == true)
        );
    }
}