@typokit/plugin-axum 0.2.1

package/src/rust_codegen/router.rs

@@ -0,0 +1,385 @@
+use std::collections::BTreeMap;
+
+use typokit_transform_native::route_compiler::RouteEntry;
+use super::GeneratedOutput;
+
+/// Generate the Axum router file from compiled route entries.
+///
+/// Produces `.typokit/router.rs` containing a `pub fn create_router() -> Router<AppState>`
+/// function with typed Axum handler registrations.
+pub fn generate_router(routes: &[RouteEntry]) -> Vec<GeneratedOutput> {
+    let mut outputs = Vec::new();
+
+    let content = generate_router_file(routes);
+    outputs.push(GeneratedOutput {
+        path: ".typokit/router.rs".to_string(),
+        content,
+        overwrite: true,
+    });
+
+    outputs
+}
+
+/// Generate the router.rs file content.
+fn generate_router_file(routes: &[RouteEntry]) -> String {
+    let mut output = String::new();
+
+    output.push_str("// AUTO-GENERATED by @typokit/transform-native — DO NOT EDIT\n\n");
+
+    // Collect unique handler module references for imports
+    let handler_modules = collect_handler_modules(routes);
+
+    // Imports
+    output.push_str("use axum::{\n");
+    output.push_str("    Router,\n");
+
+    // Collect needed routing methods
+    let methods = collect_routing_methods(routes);
+    if !methods.is_empty() {
+        output.push_str(&format!("    routing::{{{}}},\n", methods.join(", ")));
+    }
+
+    output.push_str("};\n");
+    output.push_str("use crate::app::AppState;\n");
+
+    // Import handler modules
+    for module in &handler_modules {
+        output.push_str(&format!("use crate::handlers::{};\n", module));
+    }
+
+    output.push_str("\n");
+
+    // Generate create_router function
+    output.push_str("/// Create the application router with all route registrations.\n");
+    output.push_str("pub fn create_router() -> Router<AppState> {\n");
+    output.push_str("    Router::new()\n");
+
+    // Group routes by path for chaining
+    let grouped = group_routes_by_path(routes);
+    for (path, route_methods) in &grouped {
+        let axum_path = to_axum_path(path);
+        let method_chains: Vec<String> = route_methods
+            .iter()
+            .map(|(method, handler_fn)| format!("{}({})", method, handler_fn))
+            .collect();
+
+        if method_chains.len() == 1 {
+            output.push_str(&format!(
+                "        .route(\"{}\", {})\n",
+                axum_path, method_chains[0]
+            ));
+        } else {
+            // Multiple methods on same path: chain with .method()
+            let chained = method_chains.join(".");
+            output.push_str(&format!(
+                "        .route(\"{}\", {chained})\n",
+                axum_path,
+            ));
+        }
+    }
+
+    output.push_str("}\n");
+
+    output
+}
+
+/// Collect unique handler module names from route entries.
+///
+/// Derives entity module names from the handler_ref (e.g., "UsersRoutes#GET /users" → "users").
+fn collect_handler_modules(routes: &[RouteEntry]) -> Vec<String> {
+    let mut modules = BTreeMap::new();
+    for route in routes {
+        let module = derive_handler_module(&route.handler_ref);
+        modules.entry(module).or_insert(());
+    }
+    modules.into_keys().collect()
+}
+
+/// Collect unique Axum routing method names needed (get, post, put, patch, delete).
+fn collect_routing_methods(routes: &[RouteEntry]) -> Vec<String> {
+    let mut methods = BTreeMap::new();
+    for route in routes {
+        let method = route.method.to_lowercase();
+        methods.entry(method).or_insert(());
+    }
+    methods.into_keys().collect()
+}
+
+/// Group routes by path, collecting (axum_method_fn, handler_fn) pairs per path.
+///
+/// Uses BTreeMap for deterministic ordering.
+fn group_routes_by_path(routes: &[RouteEntry]) -> BTreeMap<String, Vec<(String, String)>> {
+    let mut grouped: BTreeMap<String, Vec<(String, String)>> = BTreeMap::new();
+
+    // Sort routes for deterministic output
+    let mut sorted_routes: Vec<&RouteEntry> = routes.iter().collect();
+    sorted_routes.sort_by(|a, b| a.path.cmp(&b.path).then(a.method.cmp(&b.method)));
+
+    for route in sorted_routes {
+        let method_fn = route.method.to_lowercase();
+        let handler_fn = derive_handler_fn(route);
+        grouped
+            .entry(route.path.clone())
+            .or_default()
+            .push((method_fn, handler_fn));
+    }
+
+    grouped
+}
+
+/// Derive the handler module name from a handler_ref.
+///
+/// Handler refs follow the pattern "EntityRoutes#METHOD /path" — we extract the entity
+/// name, strip "Routes" suffix, and convert to snake_case for the module name.
+fn derive_handler_module(handler_ref: &str) -> String {
+    // Split on '#' to get the contract interface name
+    let contract_name = handler_ref
+        .split('#')
+        .next()
+        .unwrap_or(handler_ref);
+
+    // Strip "Routes" suffix if present
+    let entity = contract_name
+        .strip_suffix("Routes")
+        .or_else(|| contract_name.strip_suffix("Route"))
+        .unwrap_or(contract_name);
+
+    to_snake_case(entity)
+}
+
+/// Derive the fully qualified handler function reference from a route entry.
+///
+/// Maps HTTP method + path to handler function following the pattern:
+/// handlers::{entity}::{action}
+fn derive_handler_fn(route: &RouteEntry) -> String {
+    let module = derive_handler_module(&route.handler_ref);
+    let action = derive_action_name(route);
+    format!("{}::{}", module, action)
+}
+
+/// Derive the handler action name from the HTTP method and path.
+///
+/// Follows REST conventions:
+/// - GET /entities       → list
+/// - POST /entities      → create
+/// - GET /entities/:id   → get_by_id
+/// - PUT /entities/:id   → update
+/// - PATCH /entities/:id → update
+/// - DELETE /entities/:id → delete
+fn derive_action_name(route: &RouteEntry) -> String {
+    let has_param = route.segments.iter().any(|s| {
+        matches!(s, typokit_transform_native::route_compiler::PathSegment::Param(_))
+    });
+
+    match (route.method.as_str(), has_param) {
+        ("GET", false) => "list".to_string(),
+        ("GET", true) => "get_by_id".to_string(),
+        ("POST", false) => "create".to_string(),
+        ("PUT", true) | ("PATCH", true) => "update".to_string(),
+        ("DELETE", true) => "delete".to_string(),
+        // Fallback: use method name as action
+        (method, _) => to_snake_case(&method.to_lowercase()),
+    }
+}
+
+/// Convert Express-style path params (:id) to Axum-style (/:id).
+///
+/// Axum uses the same `:param` syntax as Express, so paths are mostly
+/// compatible. We just ensure proper formatting.
+fn to_axum_path(path: &str) -> String {
+    // Axum uses /:param syntax same as Express — paths are already compatible
+    path.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::route_compiler::{PathSegment, RouteEntry, RouteTypeInfo};
+
+    fn make_route(method: &str, path: &str, handler_ref: &str) -> RouteEntry {
+        let segments = path
+            .split('/')
+            .filter(|s| !s.is_empty())
+            .map(|s| {
+                if let Some(param) = s.strip_prefix(':') {
+                    PathSegment::Param(param.to_string())
+                } else {
+                    PathSegment::Static(s.to_string())
+                }
+            })
+            .collect();
+
+        RouteEntry {
+            method: method.to_string(),
+            path: path.to_string(),
+            segments,
+            handler_ref: handler_ref.to_string(),
+            params_type: RouteTypeInfo::Void,
+            query_type: RouteTypeInfo::Void,
+            body_type: RouteTypeInfo::Void,
+            response_type: RouteTypeInfo::Void,
+        }
+    }
+
+    #[test]
+    fn test_generate_router_basic() {
+        let routes = vec![
+            make_route("GET", "/users", "UsersRoutes#GET /users"),
+            make_route("POST", "/users", "UsersRoutes#POST /users"),
+            make_route("GET", "/users/:id", "UsersRoutes#GET /users/:id"),
+        ];
+
+        let outputs = generate_router(&routes);
+        assert_eq!(outputs.len(), 1);
+        assert_eq!(outputs[0].path, ".typokit/router.rs");
+        assert!(outputs[0].overwrite);
+
+        let content = &outputs[0].content;
+        assert!(content.contains("pub fn create_router() -> Router<AppState>"));
+        assert!(content.contains("use crate::handlers::users;"));
+        assert!(content.contains("users::list"));
+        assert!(content.contains("users::create"));
+        assert!(content.contains("users::get_by_id"));
+    }
+
+    #[test]
+    fn test_generate_router_multiple_entities() {
+        let routes = vec![
+            make_route("GET", "/users", "UsersRoutes#GET /users"),
+            make_route("GET", "/todos", "TodosRoutes#GET /todos"),
+            make_route("POST", "/todos", "TodosRoutes#POST /todos"),
+        ];
+
+        let outputs = generate_router(&routes);
+        let content = &outputs[0].content;
+
+        assert!(content.contains("use crate::handlers::todos;"));
+        assert!(content.contains("use crate::handlers::users;"));
+        assert!(content.contains("todos::list"));
+        assert!(content.contains("todos::create"));
+        assert!(content.contains("users::list"));
+    }
+
+    #[test]
+    fn test_generate_router_crud_operations() {
+        let routes = vec![
+            make_route("GET", "/users", "UsersRoutes#GET /users"),
+            make_route("POST", "/users", "UsersRoutes#POST /users"),
+            make_route("GET", "/users/:id", "UsersRoutes#GET /users/:id"),
+            make_route("PUT", "/users/:id", "UsersRoutes#PUT /users/:id"),
+            make_route("DELETE", "/users/:id", "UsersRoutes#DELETE /users/:id"),
+        ];
+
+        let outputs = generate_router(&routes);
+        let content = &outputs[0].content;
+
+        assert!(content.contains("users::list"));
+        assert!(content.contains("users::create"));
+        assert!(content.contains("users::get_by_id"));
+        assert!(content.contains("users::update"));
+        assert!(content.contains("users::delete"));
+    }
+
+    #[test]
+    fn test_derive_handler_module() {
+        assert_eq!(derive_handler_module("UsersRoutes#GET /users"), "users");
+        assert_eq!(derive_handler_module("TodosRoutes#POST /todos"), "todos");
+        assert_eq!(
+            derive_handler_module("ProjectsRoute#GET /projects"),
+            "projects"
+        );
+    }
+
+    #[test]
+    fn test_derive_action_name() {
+        let list = make_route("GET", "/users", "UsersRoutes#GET /users");
+        assert_eq!(derive_action_name(&list), "list");
+
+        let create = make_route("POST", "/users", "UsersRoutes#POST /users");
+        assert_eq!(derive_action_name(&create), "create");
+
+        let get = make_route("GET", "/users/:id", "UsersRoutes#GET /users/:id");
+        assert_eq!(derive_action_name(&get), "get_by_id");
+
+        let update = make_route("PUT", "/users/:id", "UsersRoutes#PUT /users/:id");
+        assert_eq!(derive_action_name(&update), "update");
+
+        let delete = make_route("DELETE", "/users/:id", "UsersRoutes#DELETE /users/:id");
+        assert_eq!(derive_action_name(&delete), "delete");
+
+        let patch = make_route("PATCH", "/users/:id", "UsersRoutes#PATCH /users/:id");
+        assert_eq!(derive_action_name(&patch), "update");
+    }
+
+    #[test]
+    fn test_to_axum_path() {
+        assert_eq!(to_axum_path("/users"), "/users");
+        assert_eq!(to_axum_path("/users/:id"), "/users/:id");
+        assert_eq!(to_axum_path("/users/:id/todos"), "/users/:id/todos");
+    }
+
+    #[test]
+    fn test_collect_routing_methods() {
+        let routes = vec![
+            make_route("GET", "/users", "UsersRoutes#GET /users"),
+            make_route("POST", "/users", "UsersRoutes#POST /users"),
+            make_route("GET", "/users/:id", "UsersRoutes#GET /users/:id"),
+            make_route("DELETE", "/users/:id", "UsersRoutes#DELETE /users/:id"),
+        ];
+
+        let methods = collect_routing_methods(&routes);
+        assert_eq!(methods, vec!["delete", "get", "post"]);
+    }
+
+    #[test]
+    fn test_same_path_multiple_methods() {
+        let routes = vec![
+            make_route("GET", "/users", "UsersRoutes#GET /users"),
+            make_route("POST", "/users", "UsersRoutes#POST /users"),
+        ];
+
+        let outputs = generate_router(&routes);
+        let content = &outputs[0].content;
+
+        // Should combine methods on same path with method chaining
+        assert!(content.contains("get(users::list)"));
+        assert!(content.contains("post(users::create)"));
+    }
+
+    #[test]
+    fn test_router_output_is_deterministic() {
+        let routes = vec![
+            make_route("DELETE", "/users/:id", "UsersRoutes#DELETE /users/:id"),
+            make_route("GET", "/users", "UsersRoutes#GET /users"),
+            make_route("POST", "/todos", "TodosRoutes#POST /todos"),
+        ];
+
+        let output1 = generate_router(&routes);
+        let output2 = generate_router(&routes);
+
+        assert_eq!(output1[0].content, output2[0].content);
+    }
+
+    #[test]
+    fn test_router_uses_auto_generated_header() {
+        let routes = vec![make_route("GET", "/health", "HealthRoutes#GET /health")];
+        let outputs = generate_router(&routes);
+        assert!(outputs[0].content.contains("AUTO-GENERATED"));
+    }
+}