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

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

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

{fusion_framework-1.2.3 → 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.3"
+version = "1.2.4"
 edition = "2024"
 
 [workspace.dependencies]

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

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

{fusion_framework-1.2.3 → 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.3 → 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,15 +232,33 @@ 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> {
@@ -311,84 +329,190 @@ pub fn register_route(
 
     let class_name: String = api_cls.name()?.extract()?;
     let version = normalize_api_version(version);
-    let mut resolved = resolve_route_path(template, &class_name);
+    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() {
-        // Prefix the resolved api path with version: `v1/api/` style.
-        let trimmed = resolved.trim_start_matches('/');
-        resolved = format!("{}/{}", v, trimmed);
+        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(())
@@ -739,30 +863,26 @@ pub fn openapi_spec_for(version: Option<&str>) -> serde_json::Value {
         if !route_matches_version_filter(r.version.as_deref(), version) {
             continue;
         }
-        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);
-
-        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",
@@ -784,20 +904,20 @@ pub fn openapi_spec_for(version: Option<&str>) -> 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" }
@@ -834,7 +954,6 @@ pub fn openapi_spec_for(version: Option<&str>) -> 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!({
@@ -843,25 +962,23 @@ pub fn openapi_spec_for(version: Option<&str>) -> 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.3 → fusion_framework-1.2.4}/pyproject.toml

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

fusion_framework-1.2.4/python/fusion_framework/http_route.py

@@ -0,0 +1,116 @@
+"""Method-level HTTP route decorators (custom paths + verbs)."""
+
+from __future__ import annotations
+
+from typing import Callable, Optional, Sequence, TypeVar
+
+F = TypeVar("F", bound=Callable[..., object])
+
+
+def _http_route(
+    http_method: str,
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    def decorator(fn: F) -> F:
+        fn.__fusion_http_route__ = {
+            "method": http_method.lower(),
+            "template": route,
+            "tags": list(tags or []),
+            "desc": desc,
+            "title": title,
+            "deprecated": deprecated,
+        }
+        return fn
+
+    return decorator
+
+
+def http_get(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("get", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+def http_post(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("post", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+def http_put(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("put", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+def http_patch(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("patch", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+def http_delete(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("delete", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+def http_head(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("head", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+def http_options(
+    route: str,
+    *,
+    tags: Optional[Sequence[str]] = None,
+    desc: Optional[str] = None,
+    title: Optional[str] = None,
+    deprecated: bool = False,
+) -> Callable[[F], F]:
+    return _http_route("options", route, tags=tags, desc=desc, title=title, deprecated=deprecated)
+
+
+HttpGet = http_get
+HttpPost = http_post
+HttpPut = http_put
+HttpPatch = http_patch
+HttpDelete = http_delete
+HttpHead = http_head
+HttpOptions = http_options

{fusion_framework-1.2.3 → fusion_framework-1.2.4}/python/fusion_framework/middleware.py

@@ -241,13 +241,13 @@ def framework_headers() -> Middleware:
                     hdr, "FRAMEWORK_POWERED_BY", "Fusion Framework"
                 ),
                 getattr(hdr, "X_FRAMEWORK", "X-Framework"): getattr(hdr, "FRAMEWORK_ID", "Fusion"),
-                getattr(hdr, "X_FUSION_VERSION", "X-Fusion-Version"): "1.2.3",
+                getattr(hdr, "X_FUSION_VERSION", "X-Fusion-Version"): "1.2.4",
             }
         except Exception:
             extra = {
                 "X-Powered-By": "Fusion Framework",
                 "X-Framework": "Fusion",
-                "X-Fusion-Version": "1.2.3",
+                "X-Fusion-Version": "1.2.4",
             }
 
     def middleware(request: RequestDict, call_next: Callable[[RequestDict], Any]) -> Any:

{fusion_framework-1.2.3 → fusion_framework-1.2.4}/python/fusion_framework/route.py

@@ -12,15 +12,45 @@ from fusion_framework._fusion import (
     resolve_route_path,
 )
 from fusion_framework.api import FusionBaseApi
+from fusion_framework.http_route import (
+    HttpDelete,
+    HttpGet,
+    HttpHead,
+    HttpOptions,
+    HttpPatch,
+    HttpPost,
+    HttpPut,
+    http_delete,
+    http_get,
+    http_head,
+    http_options,
+    http_patch,
+    http_post,
+    http_put,
+)
 from fusion_framework.middleware import require_roles
 
 __all__ = [
     "HTTP_METHODS",
+    "HttpDelete",
+    "HttpGet",
+    "HttpHead",
+    "HttpOptions",
+    "HttpPatch",
+    "HttpPost",
+    "HttpPut",
     "api_resource_name",
+    "clear_registry",
+    "http_delete",
+    "http_get",
+    "http_head",
+    "http_options",
+    "http_patch",
+    "http_post",
+    "http_put",
     "resolve_route_path",
     "route",
     "router",
-    "clear_registry",
 ]
 
 

fusion_framework-1.2.4/python/fusion_framework/test_http_route.py

@@ -0,0 +1,47 @@
+"""Tests for custom HTTP method routes (@http_get / HttpGet)."""
+
+from fusion_framework._fusion import clear_routes
+from fusion_framework.api import FusionBaseApi
+from fusion_framework.http_route import http_get
+from fusion_framework.route import route
+
+
+def setup_function():
+    clear_routes()
+
+
+def teardown_function():
+    clear_routes()
+
+
+def test_custom_http_get_with_action_token():
+    @route("/api/[module]")
+    class UserModule(FusionBaseApi):
+        @http_get("test/[action]")
+        def UserAction(self):
+            return {"ok": True}
+
+    from fusion_framework._fusion import openapi_spec
+
+    spec = openapi_spec()
+    assert "/api/user/test/user" in spec["paths"]
+    assert "get" in spec["paths"]["/api/user/test/user"]
+    assert spec["paths"]["/api/user/test/user"]["get"]["operationId"] == "UserModule_UserAction"
+
+
+def test_convention_and_custom_routes_coexist():
+    @route("/api/[module]")
+    class ProductModule(FusionBaseApi):
+        def get(self):
+            return {"mode": "convention"}
+
+        @http_get("catalog/[action]")
+        def ListAction(self):
+            return {"mode": "custom"}
+
+    from fusion_framework._fusion import openapi_spec
+
+    spec = openapi_spec()
+    assert "/api/product" in spec["paths"]
+    assert "get" in spec["paths"]["/api/product"]
+    assert "/api/product/catalog/list" in spec["paths"]

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

@@ -1,56 +0,0 @@
-//! 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()
-}
-
-/// 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))
-}
-
-#[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}"
-        );
-    }
-}