fusion-framework 1.2.2__tar.gz → 1.2.4__tar.gz

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/Cargo.lock

@@ -124,7 +124,7 @@ checksum = "3f9eec918d3f24069decb9af1554cad7c880e2da24a9afd88aca000531ab82c1"
 
 [[package]]
 name = "fusion-core"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "bytes",
  "console",
@@ -138,7 +138,7 @@ dependencies = [
 
 [[package]]
 name = "fusion-ffi"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "bytes",
  "fusion-core",
@@ -148,7 +148,7 @@ dependencies = [
 
 [[package]]
 name = "fusion-node"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "fusion-core",
  "napi",
@@ -161,7 +161,7 @@ dependencies = [
 
 [[package]]
 name = "fusion-py"
-version = "1.2.2"
+version = "1.2.4"
 dependencies = [
  "bytes",
  "fusion-core",

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/Cargo.toml

@@ -3,7 +3,7 @@ resolver = "2"
 members = ["crates/fusion-core", "crates/fusion-py"]
 
 [workspace.package]
-version = "1.2.2"
+version = "1.2.4"
 edition = "2024"
 
 [workspace.dependencies]

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fusion-framework
-Version: 1.2.2
+Version: 1.2.4
 Classifier: Programming Language :: Rust
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Programming Language :: Python :: 3

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/crates/fusion-core/src/lib.rs

@@ -26,7 +26,10 @@ pub use headers::{
     X_FRAMEWORK, X_FUSION_VERSION, X_POWERED_BY,
 };
 pub use http_error::HttpError;
-pub use naming::{HTTP_METHODS, api_resource_name, resolve_route_path};
+pub use naming::{
+    HTTP_METHODS, api_action_name, api_resource_name, join_route_paths, resolve_handler_route,
+    resolve_method_route_path, resolve_route_path,
+};
 pub use request::{parse_query, Request};
 pub use response::Response;
 pub use router::Router;

fusion_framework-1.2.4/crates/fusion-core/src/naming.rs

@@ -0,0 +1,111 @@
+//! Shared route naming helpers used by all language bindings.
+
+/// Canonical HTTP handler method names (lowercase).
+pub const HTTP_METHODS: &[&str] = &["get", "post", "put", "patch", "delete", "head", "options"];
+
+/// `MyFirstModule` → `myfirst`; names without a `Module`/`MODULE` suffix are lowercased as-is.
+pub fn api_resource_name(class_name: &str) -> String {
+    let stem = if let Some(stem) = class_name.strip_suffix("Module") {
+        if !stem.is_empty() {
+            stem
+        } else {
+            class_name
+        }
+    } else if let Some(stem) = class_name.strip_suffix("MODULE") {
+        if !stem.is_empty() {
+            stem
+        } else {
+            class_name
+        }
+    } else {
+        class_name
+    };
+    stem.to_lowercase()
+}
+
+/// `UserAction` → `user`; strips trailing `Action` / `ACTION` then lowercases.
+pub fn api_action_name(method_name: &str) -> String {
+    let stem = if let Some(stem) = method_name.strip_suffix("Action") {
+        if !stem.is_empty() {
+            stem
+        } else {
+            method_name
+        }
+    } else if let Some(stem) = method_name.strip_suffix("ACTION") {
+        if !stem.is_empty() {
+            stem
+        } else {
+            method_name
+        }
+    } else {
+        method_name
+    };
+    stem.to_lowercase()
+}
+
+/// Expand the reserved `[module]` token using the module class name.
+///
+/// Example: `/api/[module]/{id}` + `ProductsModule` → `/api/products/{id}`.
+/// Other `{param}` / `[param]` segments are left for the router.
+pub fn resolve_route_path(template: &str, class_name: &str) -> String {
+    template.replace("[module]", &api_resource_name(class_name))
+}
+
+/// Expand `[module]` and `[action]` tokens for a handler method route template.
+pub fn resolve_method_route_path(template: &str, class_name: &str, method_name: &str) -> String {
+    resolve_route_path(template, class_name).replace("[action]", &api_action_name(method_name))
+}
+
+/// Join a class-level base path with a method route segment.
+pub fn join_route_paths(base: &str, segment: &str) -> String {
+    let base = base.trim_end_matches('/');
+    let segment = segment.trim_matches('/');
+    if segment.is_empty() {
+        return if base.is_empty() { "/".into() } else { base.to_string() };
+    }
+    if base.is_empty() {
+        return format!("/{segment}");
+    }
+    format!("{base}/{segment}")
+}
+
+/// Resolve a method-level route template against class context.
+///
+/// Absolute templates (leading `/`) ignore the class base path.
+pub fn resolve_handler_route(
+    class_base_path: &str,
+    method_template: &str,
+    class_name: &str,
+    method_name: &str,
+) -> String {
+    let resolved = resolve_method_route_path(method_template, class_name, method_name);
+    if method_template.starts_with('/') {
+        join_route_paths("", &resolved.trim_start_matches('/'))
+    } else {
+        join_route_paths(class_base_path, &resolved)
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn strips_module_suffix_and_lowercases() {
+        assert_eq!(api_resource_name("ProductsModule"), "products");
+        assert_eq!(api_resource_name("MyFirstMODULE"), "myfirst");
+        assert_eq!(api_resource_name("Health"), "health");
+    }
+
+    #[test]
+    fn expands_module_token() {
+        assert_eq!(
+            resolve_route_path("/test/[module]", "ProductsModule"),
+            "/test/products"
+        );
+        assert_eq!(
+            resolve_route_path("/api/[module]/{id}", "UserModule"),
+            "/api/user/{id}"
+        );
+    }
+}

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/crates/fusion-py/src/api_types.rs

@@ -2,7 +2,7 @@ use std::collections::HashMap;
 use std::sync::Mutex;
 
 use fusion_core::{
-    HttpError, ParamKind, ParamSpec, Request, bind_args, build_response, resolve_route_path,
+    HttpError, ParamKind, ParamSpec, Request, bind_args, build_response, resolve_handler_route,
     HTTP_METHODS,
 };
 use pyo3::exceptions::PyRuntimeError;
@@ -232,13 +232,79 @@ pub fn is_http_exception(py: Python<'_>, err: &Bound<'_, PyAny>) -> Option<Py<Py
 
 // ─── Route registry ──────────────────────────────────────────────────────────
 
-struct RegisteredRoute {
+struct RouteMountSlot {
     path: String,
+    http_method: String,
+    handler_method: String,
+    specs: Vec<ParamSpec>,
+    swagger: SwaggerMeta,
+}
+
+impl Clone for RouteMountSlot {
+    fn clone(&self) -> Self {
+        Self {
+            path: self.path.clone(),
+            http_method: self.http_method.clone(),
+            handler_method: self.handler_method.clone(),
+            specs: self.specs.clone(),
+            swagger: self.swagger.clone(),
+        }
+    }
+}
+
+struct RegisteredRoute {
     api_name: String,
     api_cls: Py<PyType>,
-    method_specs: HashMap<String, Vec<ParamSpec>>,
-    swagger: SwaggerMeta,
     middleware: Vec<Py<PyAny>>,
+    /// Normalized route version (`v1`), if the `@route(..., version=)` was set.
+    version: Option<String>,
+    slots: Vec<RouteMountSlot>,
+}
+
+fn normalize_api_version(version: Option<String>) -> Option<String> {
+    version.and_then(|raw| {
+        let trimmed = raw.trim().trim_matches('/').to_string();
+        if trimmed.is_empty() {
+            None
+        } else {
+            Some(trimmed)
+        }
+    })
+}
+
+fn route_matches_version_filter(route_version: Option<&str>, filter: Option<&str>) -> bool {
+    match filter {
+        None => true,
+        Some(label) if label.is_empty() || label.eq_ignore_ascii_case("default") => {
+            route_version.map(str::is_empty).unwrap_or(true)
+        }
+        Some(label) => route_version
+            .map(|v| v.eq_ignore_ascii_case(label))
+            .unwrap_or(false),
+    }
+}
+
+/// Unique `@route(version=...)` values in registration order.
+pub fn route_versions() -> Vec<String> {
+    let Ok(guard) = REGISTRY.lock() else {
+        return Vec::new();
+    };
+    let mut versions = Vec::new();
+    for route in guard.iter() {
+        if let Some(version) = route.version.as_ref() {
+            if !versions.iter().any(|existing| existing == version) {
+                versions.push(version.clone());
+            }
+        }
+    }
+    versions
+}
+
+pub fn has_unversioned_routes() -> bool {
+    let Ok(guard) = REGISTRY.lock() else {
+        return false;
+    };
+    guard.iter().any(|route| route.version.is_none())
 }
 
 static REGISTRY: Mutex<Vec<RegisteredRoute>> = Mutex::new(Vec::new());
@@ -262,86 +328,191 @@ pub fn register_route(
     let py = api_cls.py();
 
     let class_name: String = api_cls.name()?.extract()?;
-    let mut resolved = resolve_route_path(template, &class_name);
-    if let Some(version) = version {
-        let v = version.trim().trim_matches('/');
-        if !v.is_empty() {
-            // Prefix the resolved api path with version: `v1/api/` style.
-            let trimmed = resolved.trim_start_matches('/');
-            resolved = format!("{}/{}", v, trimmed);
-        }
+    let version = normalize_api_version(version);
+    let mut class_base_path = fusion_core::resolve_route_path(template, &class_name);
+    if !class_base_path.starts_with('/') {
+        class_base_path = format!("/{class_base_path}");
+    }
+    if let Some(v) = version.as_deref() {
+        let trimmed = class_base_path.trim_start_matches('/');
+        class_base_path = format!("/{v}/{}", trimmed.trim_start_matches('/'));
+    }
+
+    let class_swagger = SwaggerMeta {
+        tags,
+        description,
+        title,
+        deprecated,
+    };
+
+    let mut slots = Vec::new();
+    let mut custom_handlers = std::collections::HashSet::new();
+
+    for (method_name, method) in iter_class_callables(py, &api_cls)? {
+        let method = method.bind(py);
+        let Some(meta) = read_http_route_meta(&method)? else {
+            continue;
+        };
+        custom_handlers.insert(method_name.clone());
+        let path = resolve_handler_route(
+            &class_base_path,
+            &meta.template,
+            &class_name,
+            &method_name,
+        );
+        let specs = extract_param_specs(py, &method)?;
+        slots.push(RouteMountSlot {
+            path,
+            http_method: meta.http_method,
+            handler_method: method_name,
+            specs,
+            swagger: meta.swagger,
+        });
     }
 
-    let mut method_specs = HashMap::new();
     for method_name in HTTP_METHODS {
+        if custom_handlers.contains(*method_name) {
+            continue;
+        }
         if !defines_method(&api_cls, method_name)? {
             continue;
         }
         let method = api_cls.getattr(method_name)?;
-        method_specs.insert(
-            method_name.to_string(),
-            extract_param_specs(py, &method)?,
-        );
+        slots.push(RouteMountSlot {
+            path: class_base_path.clone(),
+            http_method: (*method_name).to_string(),
+            handler_method: (*method_name).to_string(),
+            specs: extract_param_specs(py, &method)?,
+            swagger: class_swagger.clone(),
+        });
     }
 
-    api_cls.setattr("__fusion_path__", &resolved)?;
+    let primary_path = slots
+        .first()
+        .map(|s| s.path.clone())
+        .unwrap_or_else(|| class_base_path.clone());
+
+    api_cls.setattr("__fusion_path__", &primary_path)?;
     api_cls.setattr("__fusion_path_template__", template)?;
 
     REGISTRY
         .lock()
         .map_err(|_| PyRuntimeError::new_err("registry lock poisoned"))?
         .push(RegisteredRoute {
-            path: resolved.clone(),
-            api_name: class_name.clone(),
+            api_name: class_name,
             api_cls: api_cls.unbind(),
-            method_specs,
-            swagger: SwaggerMeta {
-                tags,
-                description,
-                title,
-                deprecated,
-            },
             middleware,
+            version,
+            slots,
         });
 
-    Ok(resolved)
+    Ok(primary_path)
+}
+
+struct HttpRouteMeta {
+    http_method: String,
+    template: String,
+    swagger: SwaggerMeta,
+}
+
+fn read_http_route_meta(method: &Bound<'_, PyAny>) -> PyResult<Option<HttpRouteMeta>> {
+    if !method.hasattr("__fusion_http_route__")? {
+        return Ok(None);
+    }
+    let meta = method.getattr("__fusion_http_route__")?;
+    let dict = meta.downcast::<PyDict>()?;
+    let http_method: String = dict
+        .get_item("method")?
+        .and_then(|v| v.extract().ok())
+        .unwrap_or_else(|| "get".to_string());
+    let template: String = dict
+        .get_item("template")?
+        .and_then(|v| v.extract().ok())
+        .ok_or_else(|| PyRuntimeError::new_err("http route template required"))?;
+    let tags: Vec<String> = dict
+        .get_item("tags")?
+        .and_then(|v| v.extract().ok())
+        .unwrap_or_default();
+    let description = dict
+        .get_item("desc")?
+        .and_then(|v| v.extract().ok());
+    let title = dict
+        .get_item("title")?
+        .and_then(|v| v.extract().ok());
+    let deprecated = dict
+        .get_item("deprecated")?
+        .and_then(|v| v.extract().ok())
+        .unwrap_or(false);
+    Ok(Some(HttpRouteMeta {
+        http_method: http_method.to_ascii_lowercase(),
+        template,
+        swagger: SwaggerMeta {
+            tags,
+            description,
+            title,
+            deprecated,
+        },
+    }))
+}
+
+fn iter_class_callables(
+    py: Python<'_>,
+    api_cls: &Bound<'_, PyType>,
+) -> PyResult<Vec<(String, Py<PyAny>)>> {
+    let inspect = py.import("inspect")?;
+    let members = inspect.call_method1("getmembers", (api_cls,))?;
+    let mut out = Vec::new();
+    for item in members.try_iter()? {
+        let item = item?;
+        let (name, value): (String, Bound<'_, PyAny>) = item.extract()?;
+        if name.starts_with('_') {
+            continue;
+        }
+        if value.hasattr("__func__")? || inspect.call_method1("isfunction", (value.clone(),))?.is_truthy()? {
+            out.push((name, value.unbind()));
+        } else if inspect.call_method1("ismethod", (value.clone(),))?.is_truthy()? {
+            out.push((name, value.unbind()));
+        }
+    }
+    Ok(out)
 }
 
 pub fn mount_routes(app: &super::PyApp) -> PyResult<()> {
-    let routes: Vec<(String, Py<PyType>, HashMap<String, Vec<ParamSpec>>, Vec<Py<PyAny>>)> =
-        Python::with_gil(|py| {
-            let guard = REGISTRY
-                .lock()
-                .map_err(|_| PyRuntimeError::new_err("registry lock poisoned"))?;
-            Ok::<_, PyErr>(guard
+    let routes: Vec<(Vec<RouteMountSlot>, Py<PyType>, Vec<Py<PyAny>>)> = Python::with_gil(|py| {
+        let guard = REGISTRY
+            .lock()
+            .map_err(|_| PyRuntimeError::new_err("registry lock poisoned"))?;
+        Ok::<_, PyErr>(
+            guard
                 .iter()
                 .map(|r| {
                     (
-                        r.path.clone(),
+                        r.slots.clone(),
                         r.api_cls.clone_ref(py),
-                        r.method_specs.clone(),
                         r.middleware.iter().map(|m| m.clone_ref(py)).collect(),
                     )
                 })
-                .collect())
-        })?;
+                .collect(),
+        )
+    })?;
 
-    for (path, api_cls, method_specs, middleware) in routes {
-        for method_name in HTTP_METHODS {
-            let Some(specs) = method_specs.get(*method_name) else {
-                continue;
-            };
+    for (slots, api_cls, middleware) in routes {
+        for slot in slots {
             let handler = Python::with_gil(|py| -> PyResult<PyObject> {
                 let route_handler = RouteHandler {
                     api_cls: api_cls.clone_ref(py),
-                    method_name: (*method_name).to_string(),
-                    specs: specs.clone(),
+                    method_name: slot.handler_method.clone(),
+                    specs: slot.specs.clone(),
                     middleware: middleware.iter().map(|m| m.clone_ref(py)).collect(),
                 };
                 Ok(Py::new(py, route_handler)?.into_any().into())
             })?;
 
-            app.route((*method_name).to_uppercase(), path.clone(), handler)?;
+            app.route(
+                slot.http_method.to_ascii_uppercase(),
+                slot.path.clone(),
+                handler,
+            )?;
         }
     }
     Ok(())
@@ -668,6 +839,15 @@ fn annotation_kind(py: Python<'_>, annotation: &Bound<'_, PyAny>) -> PyResult<Pa
 }
 
 pub fn openapi_spec() -> serde_json::Value {
+    openapi_spec_for(None)
+}
+
+/// Build an OpenAPI document.
+///
+/// - `None` — every registered route
+/// - `Some("default")` / `Some("")` — routes without a version
+/// - `Some("v1")` — only that API version
+pub fn openapi_spec_for(version: Option<&str>) -> serde_json::Value {
     use serde_json::{json, Map, Value};
     const OPENAPI_VERSION: &str = "3.0.3";
 
@@ -680,30 +860,29 @@ pub fn openapi_spec() -> serde_json::Value {
     let mut paths: Map<String, Value> = Map::new();
 
     for r in routes_guard.iter() {
-        let resolved_path = if r.path.starts_with('/') {
-            r.path.clone()
-        } else {
-            format!("/{}", r.path)
-        };
-
-        let path_params = extract_path_params_from_pattern(&resolved_path);
+        if !route_matches_version_filter(r.version.as_deref(), version) {
+            continue;
+        }
 
-        let mut methods_obj: Map<String, Value> = Map::new();
+        for slot in &r.slots {
+            let resolved_path = if slot.path.starts_with('/') {
+                slot.path.clone()
+            } else {
+                format!("/{}", slot.path)
+            };
 
-        for (method, specs) in &r.method_specs {
-            let method_upper = method.to_ascii_uppercase();
-            let method_lower = method.to_string();
+            let path_params = extract_path_params_from_pattern(&resolved_path);
+            let method_upper = slot.http_method.to_ascii_uppercase();
+            let method_lower = slot.http_method.to_ascii_lowercase();
 
             let mut operation_params: Vec<Value> = Vec::new();
             let mut body_properties: Map<String, Value> = Map::new();
             let mut body_required: Vec<String> = Vec::new();
 
-            for spec in specs {
+            for spec in &slot.specs {
                 let nullable = spec.optional || spec.has_default;
                 let required = !nullable;
                 if path_params.iter().any(|p| p == &spec.name) {
-                    // OpenAPI normally requires path params, but if the Python
-                    // signature marks them Optional / defaulted, expose that in Swagger.
                     operation_params.push(json!({
                         "name": spec.name,
                         "in": "path",
@@ -725,20 +904,20 @@ pub fn openapi_spec() -> serde_json::Value {
                 }
             }
 
-            let title = r
+            let title = slot
                 .swagger
                 .title
                 .clone()
-                .unwrap_or_else(|| format!("{} {}", r.api_name, method_upper));
+                .unwrap_or_else(|| format!("{} {}", r.api_name, slot.handler_method));
 
-            let description = r.swagger.description.clone().unwrap_or_default();
-            let deprecated = r.swagger.deprecated;
+            let description = slot.swagger.description.clone().unwrap_or_default();
+            let deprecated = slot.swagger.deprecated;
 
             let mut op = json!({
-                "tags": r.swagger.tags.clone(),
+                "tags": slot.swagger.tags.clone(),
                 "summary": title,
                 "description": description,
-                "operationId": format!("{}_{}", r.api_name, method_lower),
+                "operationId": format!("{}_{}", r.api_name, slot.handler_method),
                 "deprecated": deprecated,
                 "responses": {
                     "200": { "description": "OK" }
@@ -775,7 +954,6 @@ pub fn openapi_spec() -> serde_json::Value {
                     obj.insert("requestBody".to_string(), request_body);
                 }
 
-                // Make a best-effort response schema.
                 if let Some(obj) = op.as_object_mut() {
                     if let Some(resp) = obj.get_mut("responses").and_then(|v| v.as_object_mut()) {
                         resp.insert("200".to_string(), json!({
@@ -784,25 +962,23 @@ pub fn openapi_spec() -> serde_json::Value {
                         }));
                     }
                 }
-            } else {
-                // If we only have query/path parameters, default to JSON response.
-                if let Some(obj) = op.as_object_mut() {
-                    if let Some(resp) = obj.get_mut("responses").and_then(|v| v.as_object_mut()) {
-                        resp.insert("200".to_string(), json!({
-                            "description": "OK",
-                            "content": { "application/json": { "schema": { "type": "object" } } }
-                        }));
-                    }
+            } else if let Some(obj) = op.as_object_mut() {
+                if let Some(resp) = obj.get_mut("responses").and_then(|v| v.as_object_mut()) {
+                    resp.insert("200".to_string(), json!({
+                        "description": "OK",
+                        "content": { "application/json": { "schema": { "type": "object" } } }
+                    }));
                 }
             }
 
-            methods_obj.insert(method_lower, op);
-        }
+            let methods_obj = paths.entry(resolved_path).or_insert_with(|| Value::Object(Map::new()));
+            if let Some(obj) = methods_obj.as_object_mut() {
+                obj.insert(method_lower, op);
+            }
 
-        paths.insert(resolved_path, Value::Object(methods_obj));
-        // Collect tag names.
-        for t in &r.swagger.tags {
-            tags_set.insert(t.clone());
+            for t in &slot.swagger.tags {
+                tags_set.insert(t.clone());
+            }
         }
     }
 

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/crates/fusion-py/src/lib.rs

@@ -438,11 +438,25 @@ fn py_register_route(
 }
 
 #[pyfunction(name = "openapi_spec")]
-fn py_openapi_spec(py: Python<'_>) -> PyResult<PyObject> {
-    let spec = api_types::openapi_spec();
+#[pyo3(signature = (version=None))]
+fn py_openapi_spec(py: Python<'_>, version: Option<String>) -> PyResult<PyObject> {
+    let spec = match version.as_deref() {
+        None => api_types::openapi_spec(),
+        Some(v) => api_types::openapi_spec_for(Some(v)),
+    };
     json_to_py(py, &spec)
 }
 
+#[pyfunction(name = "route_versions")]
+fn py_route_versions() -> Vec<String> {
+    api_types::route_versions()
+}
+
+#[pyfunction(name = "has_unversioned_routes")]
+fn py_has_unversioned_routes() -> bool {
+    api_types::has_unversioned_routes()
+}
+
 #[pyfunction]
 fn clear_routes() {
     clear_registry();
@@ -478,6 +492,8 @@ fn _fusion(m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(clear_routes, m)?)?;
     m.add_function(wrap_pyfunction!(http_error_to_response, m)?)?;
     m.add_function(wrap_pyfunction!(py_openapi_spec, m)?)?;
+    m.add_function(wrap_pyfunction!(py_route_versions, m)?)?;
+    m.add_function(wrap_pyfunction!(py_has_unversioned_routes, m)?)?;
     m.add("HTTP_METHODS", HTTP_METHODS)?;
     add_status_module(m)?;
     add_header_module(m)?;

{fusion_framework-1.2.2 → fusion_framework-1.2.4}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "fusion-framework"
-version = "1.2.2"
+version = "1.2.4"
 description = "Class-based HTTP framework for Python, powered by a shared Rust core"
 readme = "README.md"
 requires-python = ">=3.9"