feat: port el-ui vessels — rename crates→vessels, add El source + manifests

ui/vessels/el-services/src/binding/rest.rs

@@ -0,0 +1,147 @@
+//! REST binding — maps service methods to HTTP endpoints.
+//!
+//! Method → endpoint mapping (default convention, overridable):
+//!   `get_*`    → GET    /resource/{id}
+//!   `list_*`   → GET    /resource
+//!   `create_*` → POST   /resource
+//!   `update_*` → PUT    /resource/{id}
+//!   `delete_*` → DELETE /resource/{id}
+//!
+//! In production, use `reqwest` for the HTTP client. This implementation
+//! builds the request and returns a mock response so the binding logic
+//! can be tested without a live server.
+
+use super::{Binding, BindingKind, ServiceRequest, ServiceResponse};
+use crate::{config::ServiceConfig, ServiceError, ServiceResult};
+
+/// HTTP REST binding.
+pub struct RestBinding {
+    pub config: ServiceConfig,
+}
+
+impl RestBinding {
+    pub fn new(config: ServiceConfig) -> Self {
+        Self { config }
+    }
+
+    /// Derive the HTTP method from the service method name.
+    pub fn http_method(method_name: &str) -> &'static str {
+        let lower = method_name.to_lowercase();
+        if lower.starts_with("get_") || lower.starts_with("fetch_") || lower.starts_with("find_") {
+            "GET"
+        } else if lower.starts_with("list_") || lower.starts_with("all_") {
+            "GET"
+        } else if lower.starts_with("create_") || lower.starts_with("add_") || lower.starts_with("post_") {
+            "POST"
+        } else if lower.starts_with("update_") || lower.starts_with("edit_") || lower.starts_with("put_") {
+            "PUT"
+        } else if lower.starts_with("delete_") || lower.starts_with("remove_") {
+            "DELETE"
+        } else if lower.starts_with("patch_") {
+            "PATCH"
+        } else {
+            "POST"
+        }
+    }
+
+    /// Derive the URL path from the service name and method name.
+    /// `UserService::get_user` → `/users/{id}`
+    pub fn url_path(&self, method_name: &str, params: &std::collections::HashMap<String, String>) -> String {
+        let base = self.config.base_url.as_deref().unwrap_or("");
+        let resource = self.resource_name();
+        let http_method = Self::http_method(method_name);
+
+        // Check if there's an ID param
+        let id_param = params.get("id").or_else(|| {
+            params.values().next()
+        });
+
+        match (http_method, id_param) {
+            ("GET" | "PUT" | "DELETE", Some(id)) => {
+                format!("{}/{}/{}", base, resource, id)
+            }
+            _ => format!("{}/{}", base, resource),
+        }
+    }
+
+    /// Derive the REST resource name from the service name.
+    /// `UserService` → `users`, `OrderService` → `orders`
+    fn resource_name(&self) -> String {
+        let name = self.config.name.trim_end_matches("Service");
+        let lower = name.to_lowercase();
+        // Simple pluralization: append 's' (good enough for scaffolding)
+        if lower.ends_with('s') {
+            lower
+        } else {
+            format!("{}s", lower)
+        }
+    }
+
+    /// Build auth headers for the request.
+    pub fn auth_headers(&self) -> Vec<(String, String)> {
+        let mut headers = Vec::new();
+        if let Some(auth_header) = self.config.auth.authorization_header() {
+            headers.push(("Authorization".to_string(), auth_header));
+        }
+        if let Some((key, val)) = self.config.auth.api_key_header() {
+            headers.push((key, val));
+        }
+        headers
+    }
+
+    /// Build the full request description (for logging/testing without live HTTP).
+    pub fn build_request_description(
+        &self,
+        request: &ServiceRequest,
+    ) -> String {
+        let http_method = Self::http_method(&request.method);
+        let url = self.url_path(&request.method, &request.params);
+        let headers = self.auth_headers();
+        let body = if matches!(http_method, "POST" | "PUT" | "PATCH") {
+            serde_params_to_json(&request.params)
+        } else {
+            String::new()
+        };
+        format!(
+            "{} {}\nHeaders: {:?}\nBody: {}",
+            http_method, url, headers, body
+        )
+    }
+}
+
+/// Minimal JSON serialization for params (no serde dependency).
+pub(crate) fn serde_params_to_json(params: &std::collections::HashMap<String, String>) -> String {
+    let fields: Vec<String> = params
+        .iter()
+        .map(|(k, v)| format!("\"{}\":\"{}\"", k, v.replace('"', "\\\"")))
+        .collect();
+    format!("{{{}}}", fields.join(","))
+}
+
+impl Binding for RestBinding {
+    fn kind(&self) -> BindingKind {
+        BindingKind::Rest
+    }
+
+    fn call(&self, request: ServiceRequest) -> ServiceResult<ServiceResponse> {
+        if self.config.base_url.is_none() {
+            return Err(ServiceError::Binding(
+                "REST binding requires base_url in config".into(),
+            ));
+        }
+
+        let _description = self.build_request_description(&request);
+
+        // In production: use reqwest to make the actual HTTP call:
+        //   let client = reqwest::blocking::Client::new();
+        //   let resp = client.request(http_method, &url).headers(...).body(body).send()?;
+        //   return Ok(ServiceResponse { status: resp.status().as_u16(), body: resp.text()?, ... });
+
+        // For the framework layer: return a structured mock response so the
+        // binding selection, URL derivation, and auth logic can all be tested.
+        Ok(ServiceResponse::ok(format!(
+            "{{\"service\":\"{}\",\"method\":\"{}\"}}",
+            request.service, request.method
+        )))
+    }
+}