appstruct-codegen 0.2.0

Deterministic Rust, SQL, OpenAPI, TypeScript, and React generation for AppStruct
Documentation
use super::{auth, error_response, request_body, response, schema_ref, tenant};
use appstruct_ir::{AppIr, EntityIr};
use serde_json::{Map, Value, json};

pub(super) fn add_paths(paths: &mut Map<String, Value>, ir: &AppIr, entity: &EntityIr) {
    let name = &entity.rust_name;
    let base = format!("/api/{}/", entity.table_name);
    let security = auth::security(&entity.access.list);
    let mut tenant_parameters = Vec::new();
    if entity.tenant_scoped {
        tenant_parameters.push(tenant::parameter());
    }
    let mut export_parameters = super::entity::list_parameters(ir, entity)
        .into_iter()
        .filter(|parameter| {
            !matches!(
                parameter["name"].as_str().unwrap_or_default(),
                "page" | "page_size" | "cursor" | "limit" | "direction"
            )
        })
        .collect::<Vec<_>>();
    export_parameters.extend(tenant_parameters.clone());
    paths.insert(format!("{base}_bulk"), json!({
        "patch": { "operationId": format!("bulkUpdate{name}"), "tags": [name], "security": auth::security(&entity.access.update), "parameters": tenant_parameters.clone(), "requestBody": request_body(&format!("BulkUpdate{name}Input")), "responses": { "200": response("Bulk update result", &schema_ref("BulkResult")), "403": error_response() } },
        "delete": { "operationId": format!("bulkDelete{name}"), "tags": [name], "security": auth::security(&entity.access.delete), "parameters": tenant_parameters.clone(), "requestBody": request_body("BulkDeleteInput"), "responses": { "200": response("Bulk delete result", &schema_ref("BulkResult")), "403": error_response() } }
    }));
    paths.insert(format!("{base}_export.csv"), json!({ "get": { "operationId": format!("export{name}Csv"), "tags": [name], "security": security, "parameters": export_parameters, "responses": { "200": { "description": "Streamed CSV of the complete filtered result, limited to 10000 rows in a consistent read-only snapshot", "content": { "text/csv": { "schema": { "type": "string" } } } }, "400": error_response(), "403": error_response() } } }));
    let mut import_parameters = tenant_parameters.clone();
    import_parameters.push(json!({ "name": "Idempotency-Key", "in": "header", "required": true, "description": "UUID v4/v7 for this immutable CSV attempt; replay with identical content returns its stored result", "schema": { "type": "string", "format": "uuid" } }));
    paths.insert(format!("{base}_import.csv"), json!({ "post": { "operationId": format!("import{name}Csv"), "tags": [name], "security": auth::security(&entity.access.create), "parameters": import_parameters, "requestBody": { "required": true, "content": { "text/csv": { "schema": { "type": "string" } } } }, "responses": { "200": response("CSV import result", &schema_ref("BulkResult")), "400": error_response(), "403": error_response(), "409": error_response() } } }));
    let mut result_parameters = tenant_parameters.clone();
    result_parameters.push(json!({ "name": "batch", "in": "path", "required": true, "schema": { "type": "string", "format": "uuid" } }));
    paths.insert(format!("{base}_imports/{{batch}}"), json!({ "get": { "operationId": format!("get{name}ImportResult"), "tags": [name], "security": auth::security(&entity.access.create), "parameters": result_parameters, "responses": { "200": response("Committed result for the same actor, tenant and resource", &schema_ref("BulkResult")), "404": error_response() } } }));
    if entity.views.soft_delete {
        let mut parameters = trash_parameters();
        parameters.extend(tenant_parameters.clone());
        paths.insert(format!("{base}_trash"), json!({ "get": { "operationId": format!("list{name}Trash"), "tags": [name], "security": security, "parameters": parameters, "responses": { "200": response("Trashed resources", &schema_ref(&format!("{name}ListResponse"))), "403": error_response() } } }));
        paths.insert(format!("{base}_restore"), json!({ "post": { "operationId": format!("restore{name}"), "tags": [name], "security": auth::security(&entity.access.update), "parameters": tenant_parameters, "requestBody": request_body("BulkDeleteInput"), "responses": { "200": response("Restore result", &schema_ref("BulkResult")), "403": error_response() } } }));
    }
}

pub(super) fn add_schemas(schemas: &mut Map<String, Value>, entity: &EntityIr) {
    schemas.insert("BulkResult".to_owned(), bulk_result_schema());
    schemas.insert("BulkDeleteInput".to_owned(), bulk_delete_schema());
    schemas.insert(
        format!("BulkUpdate{}Input", entity.rust_name),
        bulk_update_schema(entity),
    );
}

fn trash_parameters() -> Vec<Value> {
    vec![
        query_parameter(
            "page",
            &json!({ "type": "integer", "minimum": 1, "default": 1 }),
        ),
        query_parameter(
            "page_size",
            &json!({ "type": "integer", "minimum": 1, "maximum": 100, "default": 25 }),
        ),
    ]
}

fn query_parameter(name: &str, schema: &Value) -> Value {
    json!({ "name": name, "in": "query", "required": false, "schema": schema })
}

fn bulk_result_schema() -> Value {
    json!({ "type": "object", "required": ["succeeded", "failed"], "properties": { "succeeded": { "type": "array", "items": { "type": "string" } }, "failed": { "type": "array", "items": { "$ref": "#/components/schemas/BulkFailure" } } } })
}

fn bulk_delete_schema() -> Value {
    json!({ "type": "object", "required": ["ids", "expected_revisions"], "properties": { "ids": { "type": "array", "items": { "type": "string" }, "minItems": 1, "maxItems": 100 }, "expected_revisions": { "type": "object", "additionalProperties": { "type": "integer", "minimum": 1 }, "maxProperties": 100 } } })
}

fn bulk_update_schema(entity: &EntityIr) -> Value {
    json!({ "type": "object", "required": ["ids", "patch", "expected_revisions"], "properties": { "ids": { "type": "array", "items": { "type": "string" }, "minItems": 1, "maxItems": 100 }, "patch": schema_ref(&format!("Update{}Input", entity.rust_name)), "expected_revisions": { "type": "object", "additionalProperties": { "type": "integer", "minimum": 1 }, "maxProperties": 100 } } })
}

pub(super) fn add_common_schemas(schemas: &mut Map<String, Value>) {
    schemas.insert("BulkFailure".to_owned(), json!({ "type": "object", "required": ["id", "code", "message"], "properties": { "id": { "type": "string" }, "code": { "type": "string" }, "message": { "type": "string" } } }));
}