@typokit/plugin-axum 0.2.1

package/src/rust_codegen/services.rs

@@ -0,0 +1,476 @@
+use std::collections::HashMap;
+
+use typokit_transform_native::type_extractor::TypeMetadata;
+use super::GeneratedOutput;
+
+/// Generate per-entity service stub files and a services/mod.rs.
+///
+/// Produces:
+/// - `src/services/{entity}.rs` per @table entity with CRUD function stubs (overwrite: false)
+/// - `src/services/mod.rs` with pub mod declarations (overwrite: true)
+pub fn generate_services(type_map: &HashMap<String, TypeMetadata>) -> Vec<GeneratedOutput> {
+    let mut outputs = Vec::new();
+    let mut module_names: Vec<String> = Vec::new();
+
+    // Collect @table entities sorted by name for deterministic output
+    let mut table_entities: Vec<&TypeMetadata> = type_map
+        .values()
+        .filter(|meta| is_table_entity(meta))
+        .collect();
+    table_entities.sort_by_key(|meta| meta.name.clone());
+
+    for meta in &table_entities {
+        let snake_name = to_snake_case(&meta.name);
+        module_names.push(snake_name.clone());
+
+        let id_type = find_id_type(meta);
+        let input_struct = format!("{}WithoutId", meta.name);
+        let content = generate_service_file(&meta.name, &snake_name, &id_type, &input_struct);
+        outputs.push(GeneratedOutput {
+            path: format!("src/services/{}.rs", snake_name),
+            content,
+            overwrite: false,
+        });
+    }
+
+    module_names.sort();
+    outputs.push(generate_services_mod(&module_names));
+
+    outputs
+}
+
+/// Generate service file content for a single entity.
+fn generate_service_file(
+    entity_name: &str,
+    snake_name: &str,
+    id_type: &str,
+    input_struct: &str,
+) -> String {
+    let mut s = String::new();
+
+    s.push_str("// AUTO-GENERATED by @typokit/transform-native\n");
+    s.push_str("// This file will NOT be overwritten — edit freely.\n\n");
+
+    s.push_str("use sqlx::PgPool;\n");
+    s.push_str("use crate::error::AppError;\n");
+    s.push_str("use crate::models;\n\n");
+
+    // list
+    s.push_str(&format!(
+        "/// List all {}s with pagination.\n",
+        snake_name
+    ));
+    s.push_str(&format!(
+        "pub async fn list_{}(\n",
+        snake_name
+    ));
+    s.push_str("    _pool: &PgPool,\n");
+    s.push_str("    _page: u32,\n");
+    s.push_str("    _page_size: u32,\n");
+    s.push_str(&format!(
+        ") -> Result<Vec<models::{}>, AppError> {{\n",
+        entity_name
+    ));
+    s.push_str("    // TODO: Implement service-layer list logic\n");
+    s.push_str("    todo!()\n");
+    s.push_str("}\n\n");
+
+    // get_by_id
+    s.push_str(&format!(
+        "/// Get a {} by ID.\n",
+        snake_name
+    ));
+    s.push_str(&format!(
+        "pub async fn get_{}_by_id(\n",
+        snake_name
+    ));
+    s.push_str("    _pool: &PgPool,\n");
+    s.push_str(&format!(
+        "    _id: &{},\n",
+        id_type
+    ));
+    s.push_str(&format!(
+        ") -> Result<Option<models::{}>, AppError> {{\n",
+        entity_name
+    ));
+    s.push_str("    // TODO: Implement service-layer get_by_id logic\n");
+    s.push_str("    todo!()\n");
+    s.push_str("}\n\n");
+
+    // create
+    s.push_str(&format!(
+        "/// Create a new {}.\n",
+        snake_name
+    ));
+    s.push_str(&format!(
+        "pub async fn create_{}(\n",
+        snake_name
+    ));
+    s.push_str("    _pool: &PgPool,\n");
+    s.push_str(&format!(
+        "    _input: &models::{},\n",
+        input_struct
+    ));
+    s.push_str(&format!(
+        ") -> Result<models::{}, AppError> {{\n",
+        entity_name
+    ));
+    s.push_str("    // TODO: Implement service-layer create logic\n");
+    s.push_str("    todo!()\n");
+    s.push_str("}\n\n");
+
+    // update
+    s.push_str(&format!(
+        "/// Update a {} by ID.\n",
+        snake_name
+    ));
+    s.push_str(&format!(
+        "pub async fn update_{}(\n",
+        snake_name
+    ));
+    s.push_str("    _pool: &PgPool,\n");
+    s.push_str(&format!(
+        "    _id: &{},\n",
+        id_type
+    ));
+    s.push_str(&format!(
+        "    _input: &models::{},\n",
+        input_struct
+    ));
+    s.push_str(&format!(
+        ") -> Result<Option<models::{}>, AppError> {{\n",
+        entity_name
+    ));
+    s.push_str("    // TODO: Implement service-layer update logic\n");
+    s.push_str("    todo!()\n");
+    s.push_str("}\n\n");
+
+    // delete
+    s.push_str(&format!(
+        "/// Delete a {} by ID.\n",
+        snake_name
+    ));
+    s.push_str(&format!(
+        "pub async fn delete_{}(\n",
+        snake_name
+    ));
+    s.push_str("    _pool: &PgPool,\n");
+    s.push_str(&format!(
+        "    _id: &{},\n",
+        id_type
+    ));
+    s.push_str(&format!(
+        ") -> Result<Option<models::{}>, AppError> {{\n",
+        entity_name
+    ));
+    s.push_str("    // TODO: Implement service-layer delete logic\n");
+    s.push_str("    todo!()\n");
+    s.push_str("}\n");
+
+    s
+}
+
+/// Generate the `src/services/mod.rs` with pub mod declarations.
+fn generate_services_mod(module_names: &[String]) -> GeneratedOutput {
+    let mut output = String::new();
+    output.push_str("// AUTO-GENERATED by @typokit/transform-native — DO NOT EDIT\n\n");
+
+    for name in module_names {
+        output.push_str(&format!("pub mod {};\n", name));
+    }
+
+    GeneratedOutput {
+        path: "src/services/mod.rs".to_string(),
+        content: output,
+        overwrite: true,
+    }
+}
+
+/// Check if a TypeMetadata has the @table JSDoc annotation.
+fn is_table_entity(meta: &TypeMetadata) -> bool {
+    meta.jsdoc
+        .as_ref()
+        .map(|j| j.contains_key("table"))
+        .unwrap_or(false)
+}
+
+/// Find the Rust type for the @id property.
+fn find_id_type(meta: &TypeMetadata) -> String {
+    for (_name, prop) in &meta.properties {
+        if prop
+            .jsdoc
+            .as_ref()
+            .map(|j| j.contains_key("id"))
+            .unwrap_or(false)
+        {
+            return id_rust_type(&prop.type_str);
+        }
+    }
+    if let Some(prop) = meta.properties.get("id") {
+        return id_rust_type(&prop.type_str);
+    }
+    "String".to_string()
+}
+
+/// Map TS type to Rust type for ID fields.
+fn id_rust_type(type_str: &str) -> String {
+    match type_str {
+        "string" => "String".to_string(),
+        "number" => "i64".to_string(),
+        _ => "String".to_string(),
+    }
+}
+
+/// Convert a camelCase or PascalCase string to snake_case.
+fn to_snake_case(s: &str) -> String {
+    let mut result = String::new();
+    for (i, c) in s.chars().enumerate() {
+        if c.is_uppercase() {
+            if i > 0 {
+                result.push('_');
+            }
+            result.push(c.to_lowercase().next().unwrap());
+        } else {
+            result.push(c);
+        }
+    }
+    result
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use typokit_transform_native::type_extractor::PropertyMetadata;
+
+    fn make_table_entity(name: &str) -> TypeMetadata {
+        let mut jsdoc = HashMap::new();
+        jsdoc.insert("table".to_string(), "".to_string());
+
+        let mut properties = HashMap::new();
+        let mut id_jsdoc = HashMap::new();
+        id_jsdoc.insert("id".to_string(), "".to_string());
+        id_jsdoc.insert("generated".to_string(), "uuid".to_string());
+        properties.insert(
+            "id".to_string(),
+            PropertyMetadata {
+                type_str: "string".to_string(),
+                optional: false,
+                jsdoc: Some(id_jsdoc),
+            },
+        );
+        properties.insert(
+            "name".to_string(),
+            PropertyMetadata {
+                type_str: "string".to_string(),
+                optional: false,
+                jsdoc: None,
+            },
+        );
+
+        TypeMetadata {
+            name: name.to_string(),
+            properties,
+            jsdoc: Some(jsdoc),
+        }
+    }
+
+    fn make_non_table_entity(name: &str) -> TypeMetadata {
+        let mut properties = HashMap::new();
+        properties.insert(
+            "id".to_string(),
+            PropertyMetadata {
+                type_str: "string".to_string(),
+                optional: false,
+                jsdoc: None,
+            },
+        );
+
+        TypeMetadata {
+            name: name.to_string(),
+            properties,
+            jsdoc: None,
+        }
+    }
+
+    #[test]
+    fn test_generate_services_empty_type_map() {
+        let type_map = HashMap::new();
+        let outputs = generate_services(&type_map);
+        // Should only produce mod.rs
+        assert_eq!(outputs.len(), 1);
+        assert_eq!(outputs[0].path, "src/services/mod.rs");
+        assert!(outputs[0].overwrite);
+    }
+
+    #[test]
+    fn test_generate_services_skips_non_table_entities() {
+        let mut type_map = HashMap::new();
+        type_map.insert("Config".to_string(), make_non_table_entity("Config"));
+
+        let outputs = generate_services(&type_map);
+        // Only mod.rs — no service file for non-table entity
+        assert_eq!(outputs.len(), 1);
+        assert_eq!(outputs[0].path, "src/services/mod.rs");
+    }
+
+    #[test]
+    fn test_generate_services_for_table_entity() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        assert_eq!(outputs.len(), 2); // user.rs + mod.rs
+
+        let user_service = outputs.iter().find(|o| o.path == "src/services/user.rs").unwrap();
+        assert!(!user_service.overwrite);
+        assert!(user_service.content.contains("pub async fn list_user("));
+        assert!(user_service.content.contains("pub async fn get_user_by_id("));
+        assert!(user_service.content.contains("pub async fn create_user("));
+        assert!(user_service.content.contains("pub async fn update_user("));
+        assert!(user_service.content.contains("pub async fn delete_user("));
+    }
+
+    #[test]
+    fn test_service_file_imports_model_types() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        let user_service = outputs.iter().find(|o| o.path == "src/services/user.rs").unwrap();
+        assert!(user_service.content.contains("use crate::models;"));
+        assert!(user_service.content.contains("models::User"));
+        assert!(user_service.content.contains("models::UserWithoutId"));
+    }
+
+    #[test]
+    fn test_service_file_has_correct_signatures() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        let user_service = outputs.iter().find(|o| o.path == "src/services/user.rs").unwrap();
+
+        // list: returns Vec
+        assert!(user_service.content.contains("-> Result<Vec<models::User>, AppError>"));
+        // get_by_id: returns Option
+        assert!(user_service.content.contains("-> Result<Option<models::User>, AppError>"));
+        // create: returns entity
+        assert!(user_service.content.contains(") -> Result<models::User, AppError>"));
+        // update: returns Option
+        assert!(user_service.content.contains("_input: &models::UserWithoutId"));
+        // delete: returns Option
+        assert!(user_service.content.contains("pub async fn delete_user("));
+    }
+
+    #[test]
+    fn test_service_file_overwrite_false() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        let user_service = outputs.iter().find(|o| o.path == "src/services/user.rs").unwrap();
+        assert!(!user_service.overwrite);
+        assert!(user_service.content.contains("will NOT be overwritten"));
+    }
+
+    #[test]
+    fn test_services_mod_overwrite_true() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        let mod_file = outputs.iter().find(|o| o.path == "src/services/mod.rs").unwrap();
+        assert!(mod_file.overwrite);
+        assert!(mod_file.content.contains("pub mod user;"));
+    }
+
+    #[test]
+    fn test_generate_services_multiple_entities_sorted() {
+        let mut type_map = HashMap::new();
+        type_map.insert("Todo".to_string(), make_table_entity("Todo"));
+        type_map.insert("User".to_string(), make_table_entity("User"));
+        type_map.insert("Category".to_string(), make_table_entity("Category"));
+
+        let outputs = generate_services(&type_map);
+        // 3 entity files + mod.rs
+        assert_eq!(outputs.len(), 4);
+
+        let mod_file = outputs.iter().find(|o| o.path == "src/services/mod.rs").unwrap();
+        let lines: Vec<&str> = mod_file.content.lines().collect();
+        let mod_lines: Vec<&&str> = lines.iter().filter(|l| l.starts_with("pub mod")).collect();
+        assert_eq!(mod_lines.len(), 3);
+        assert_eq!(*mod_lines[0], "pub mod category;");
+        assert_eq!(*mod_lines[1], "pub mod todo;");
+        assert_eq!(*mod_lines[2], "pub mod user;");
+    }
+
+    #[test]
+    fn test_service_id_type_number() {
+        let mut type_map = HashMap::new();
+        let mut properties = HashMap::new();
+        let mut id_jsdoc = HashMap::new();
+        id_jsdoc.insert("id".to_string(), "".to_string());
+        properties.insert(
+            "id".to_string(),
+            PropertyMetadata {
+                type_str: "number".to_string(),
+                optional: false,
+                jsdoc: Some(id_jsdoc),
+            },
+        );
+        let mut jsdoc = HashMap::new();
+        jsdoc.insert("table".to_string(), "".to_string());
+        type_map.insert(
+            "Item".to_string(),
+            TypeMetadata {
+                name: "Item".to_string(),
+                properties,
+                jsdoc: Some(jsdoc),
+            },
+        );
+
+        let outputs = generate_services(&type_map);
+        let item_service = outputs.iter().find(|o| o.path == "src/services/item.rs").unwrap();
+        assert!(item_service.content.contains("_id: &i64"));
+    }
+
+    #[test]
+    fn test_service_uses_pool_and_app_error() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        let user_service = outputs.iter().find(|o| o.path == "src/services/user.rs").unwrap();
+        assert!(user_service.content.contains("use sqlx::PgPool;"));
+        assert!(user_service.content.contains("use crate::error::AppError;"));
+        assert!(user_service.content.contains("_pool: &PgPool"));
+    }
+
+    #[test]
+    fn test_service_pagination_params() {
+        let mut type_map = HashMap::new();
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs = generate_services(&type_map);
+        let user_service = outputs.iter().find(|o| o.path == "src/services/user.rs").unwrap();
+        assert!(user_service.content.contains("_page: u32"));
+        assert!(user_service.content.contains("_page_size: u32"));
+    }
+
+    #[test]
+    fn test_deterministic_output() {
+        let mut type_map = HashMap::new();
+        type_map.insert("Todo".to_string(), make_table_entity("Todo"));
+        type_map.insert("User".to_string(), make_table_entity("User"));
+
+        let outputs1 = generate_services(&type_map);
+        let outputs2 = generate_services(&type_map);
+
+        assert_eq!(outputs1.len(), outputs2.len());
+        for (a, b) in outputs1.iter().zip(outputs2.iter()) {
+            assert_eq!(a.path, b.path);
+            assert_eq!(a.content, b.content);
+            assert_eq!(a.overwrite, b.overwrite);
+        }
+    }
+}