spikard 0.8.3 → 0.10.2

data/vendor/crates/spikard-rb/src/grpc/mod.rs

@@ -1,9 +1,13 @@
 //! Ruby gRPC bindings for Spikard
 //!
-//! This module provides a bridge between Ruby code and Spikard's gRPC runtime,
-//! allowing Ruby handlers to process gRPC requests using protobuf serialization.
+//! This module provides Ruby gRPC handler integration with full streaming support:
+//! - Unary RPCs (single request, single response)
+//! - Server streaming RPCs (single request, stream of responses)
+//! - Client streaming RPCs (stream of requests, single response)
+//! - Bidirectional streaming RPCs (stream of requests, stream of responses)
 
 pub mod handler;
 
+// Re-export types for when the API is integrated
 #[allow(unused_imports)]
 pub use handler::{RubyGrpcHandler, RubyGrpcRequest, RubyGrpcResponse};

data/vendor/crates/spikard-rb/src/gvl.rs

@@ -37,7 +37,7 @@ where
     };
 
     unsafe {
-        rb_sys::rb_thread_call_with_gvl(Some(trampoline::<F, R>), &mut data as *mut _ as *mut c_void);
+        rb_sys::rb_thread_call_with_gvl(Some(trampoline::<F, R>), &raw mut data as *mut c_void);
         data.result.assume_init()
     }
 }
@@ -50,7 +50,7 @@ macro_rules! call_without_gvl {
             // Box the arguments to ensure they live on the heap for the entire duration of the FFI call
             let data = std::boxed::Box::new((
                 ($($arg,)+),
-                &mut result as *mut std::mem::MaybeUninit<$return_ty>,
+                &raw mut result as *mut std::mem::MaybeUninit<$return_ty>,
             ));
             let data_ptr = std::boxed::Box::into_raw(data) as *mut std::ffi::c_void;
 

data/vendor/crates/spikard-rb/src/handler.rs

@@ -22,21 +22,13 @@ use std::panic::AssertUnwindSafe;
 use std::pin::Pin;
 use std::sync::Arc;
 
-use crate::conversion::{
-    json_to_ruby, json_to_ruby_with_uploads, map_to_ruby_hash, multimap_to_ruby_hash, ruby_value_to_json,
-};
+use crate::conversion::ruby_value_to_json;
 use crate::gvl::with_gvl;
+use crate::request::NativeRequest;
 
-static KEY_METHOD: LazyId = LazyId::new("method");
-static KEY_PATH: LazyId = LazyId::new("path");
 static KEY_PATH_PARAMS: LazyId = LazyId::new("path_params");
 static KEY_QUERY: LazyId = LazyId::new("query");
-static KEY_RAW_QUERY: LazyId = LazyId::new("raw_query");
-static KEY_HEADERS: LazyId = LazyId::new("headers");
-static KEY_COOKIES: LazyId = LazyId::new("cookies");
 static KEY_BODY: LazyId = LazyId::new("body");
-static KEY_RAW_BODY: LazyId = LazyId::new("raw_body");
-static KEY_PARAMS: LazyId = LazyId::new("params");
 
 /// Response payload with status, headers, and body data.
 pub struct HandlerResponsePayload {
@@ -170,6 +162,7 @@ impl RubyHandler {
                 "Ruby VM unavailable while creating handler",
             ));
         };
+        let handler_value = crate::conversion::ensure_callable(&ruby, handler_value, &route.handler_name)?;
         let method_value = Opaque::from(ruby.str_new(&method).as_value());
         let path_value = Opaque::from(ruby.str_new(&path).as_value());
 
@@ -192,7 +185,7 @@ impl RubyHandler {
     ///
     /// This is used by run_server to create handlers from Ruby Procs
     pub fn new_for_server(
-        _ruby: &Ruby,
+        ruby: &Ruby,
         handler_value: Value,
         handler_name: String,
         method: String,
@@ -205,12 +198,7 @@ impl RubyHandler {
         } else {
             None
         };
-        let Ok(ruby) = Ruby::get() else {
-            return Err(Error::new(
-                magnus::exception::runtime_error(),
-                "Ruby VM unavailable while creating handler",
-            ));
-        };
+        let handler_value = crate::conversion::ensure_callable(ruby, handler_value, &handler_name)?;
         let method_value = Opaque::from(ruby.str_new(&method).as_value());
         let path_value = Opaque::from(ruby.str_new(&path).as_value());
 
@@ -255,9 +243,7 @@ impl RubyHandler {
         })
     }
 
-    fn handle_inner(&self, request_data: RequestData) -> HandlerResult {
-        let validated_params = request_data.validated_params.clone();
-
+    fn handle_inner(&self, mut request_data: RequestData) -> HandlerResult {
         let ruby = Ruby::get().map_err(|_| {
             ErrorResponseBuilder::structured_error(
                 StatusCode::INTERNAL_SERVER_ERROR,
@@ -266,20 +252,22 @@ impl RubyHandler {
             )
         })?;
 
-        let request_value = build_ruby_request(&ruby, &self.inner, &request_data, validated_params.as_ref())
-            .map_err(|err| (StatusCode::INTERNAL_SERVER_ERROR, err.to_string()))?;
+        // Extract validated_params with Arc::try_unwrap to eliminate clone if possible.
+        let validated_params = request_data
+            .validated_params
+            .take()
+            .map(|arc| Arc::try_unwrap(arc).unwrap_or_else(|a| (*a).clone()));
+
+        // Use NativeRequest for lazy field conversion — fields are only converted
+        // to Ruby objects when accessed, avoiding work for unused fields.
+        let native_request =
+            NativeRequest::from_request_data(request_data, validated_params, self.inner.upload_file_class);
+        let request_value = ruby.obj_wrap(native_request).as_value();
 
         let handler_proc = self.inner.handler_proc.get_inner_with(&ruby);
-        let handler_result = handler_proc.funcall("call", (request_value,));
-        let response_value = match handler_result {
+        let response_value = match call_handler_proc(&ruby, handler_proc, request_value) {
             Ok(value) => value,
-            Err(err) => {
-                return Err(ErrorResponseBuilder::structured_error(
-                    StatusCode::INTERNAL_SERVER_ERROR,
-                    "handler_failed",
-                    format!("Handler '{}' failed: {}", self.inner.handler_name, err),
-                ));
-            }
+            Err(err) => return Err(problem_from_ruby_error(&ruby, &self.inner, err)),
         };
 
         let handler_result = interpret_handler_response(&ruby, &self.inner, response_value).map_err(|err| {
@@ -310,7 +298,7 @@ impl RubyHandler {
         if let Some(validator) = &self.inner.response_validator {
             let candidate_body = match payload.body.clone() {
                 Some(body) => Some(body),
-                None => match try_parse_raw_body(&payload.raw_body) {
+                None => match try_parse_raw_body(payload.raw_body.as_ref()) {
                     Ok(parsed) => parsed,
                     Err(err) => {
                         return Err(ErrorResponseBuilder::structured_error(
@@ -409,15 +397,16 @@ impl Handler for RubyHandler {
     }
 }
 
-fn try_parse_raw_body(raw_body: &Option<Vec<u8>>) -> Result<Option<JsonValue>, String> {
+fn try_parse_raw_body(raw_body: Option<&Vec<u8>>) -> Result<Option<JsonValue>, String> {
     let Some(bytes) = raw_body else {
         return Ok(None);
     };
-    let text = String::from_utf8(bytes.clone()).map_err(|e| format!("Invalid UTF-8 in response body: {e}"))?;
-    if text.is_empty() {
+    if bytes.is_empty() {
         return Ok(None);
     }
-    serde_json::from_str(&text)
+    // PERFORMANCE: Use from_slice directly to avoid String allocation.
+    // serde_json handles UTF-8 validation internally.
+    serde_json::from_slice(bytes)
         .map(Some)
         .map_err(|e| format!("Failed to parse response body as JSON: {e}"))
 }
@@ -432,77 +421,166 @@ fn lookup_upload_file_class() -> Result<Option<Opaque<Value>>, Error> {
     Ok(upload_file.map(Opaque::from))
 }
 
-/// Build a Ruby Hash request object from request data.
-fn build_ruby_request(
-    ruby: &Ruby,
-    handler: &RubyHandlerInner,
-    request_data: &RequestData,
-    validated_params: Option<&JsonValue>,
-) -> Result<Value, Error> {
-    let hash = ruby.hash_new_capa(9);
+fn call_handler_proc(ruby: &Ruby, handler_proc: Value, request_value: Value) -> Result<Value, Error> {
+    let arity: i64 = handler_proc.funcall("arity", ())?;
+    if arity == 0 {
+        return handler_proc.funcall("call", ());
+    }
+
+    if arity == 1 {
+        return handler_proc.funcall("call", (request_value,));
+    }
 
-    hash.aset(*KEY_METHOD, handler.method_value.get_inner_with(ruby))?;
-    hash.aset(*KEY_PATH, handler.path_value.get_inner_with(ruby))?;
+    let (params_value, query_value, body_value) = if let Ok(request) = <&NativeRequest>::try_convert(request_value) {
+        (
+            NativeRequest::path_params(ruby, request).unwrap_or_else(|_| ruby.qnil().as_value()),
+            NativeRequest::query(ruby, request).unwrap_or_else(|_| ruby.qnil().as_value()),
+            NativeRequest::body(ruby, request).unwrap_or_else(|_| ruby.qnil().as_value()),
+        )
+    } else if let Some(hash) = RHash::from_value(request_value) {
+        (
+            hash.get(*KEY_PATH_PARAMS).unwrap_or_else(|| ruby.qnil().as_value()),
+            hash.get(*KEY_QUERY).unwrap_or_else(|| ruby.qnil().as_value()),
+            hash.get(*KEY_BODY).unwrap_or_else(|| ruby.qnil().as_value()),
+        )
+    } else {
+        (ruby.qnil().as_value(), ruby.qnil().as_value(), ruby.qnil().as_value())
+    };
+
+    if arity == 2 {
+        return handler_proc.funcall("call", (params_value, query_value));
+    }
 
-    let path_params = map_to_ruby_hash(ruby, request_data.path_params.as_ref())?;
-    hash.aset(*KEY_PATH_PARAMS, path_params)?;
+    handler_proc.funcall("call", (params_value, query_value, body_value))
+}
 
-    let query_value = json_to_ruby(ruby, &request_data.query_params)?;
-    hash.aset(*KEY_QUERY, query_value)?;
+fn problem_from_ruby_error(ruby: &Ruby, handler: &RubyHandlerInner, err: Error) -> (StatusCode, String) {
+    let mut status = StatusCode::INTERNAL_SERVER_ERROR;
+    let mut extensions: HashMap<String, JsonValue> = HashMap::new();
+    let mut detail = ruby_error_message(ruby, &err);
 
-    let raw_query = multimap_to_ruby_hash(ruby, request_data.raw_query_params.as_ref())?;
-    hash.aset(*KEY_RAW_QUERY, raw_query)?;
+    if err.is_kind_of(ruby.exception_arg_error()) {
+        status = StatusCode::BAD_REQUEST;
+    }
 
-    let headers = map_to_ruby_hash(ruby, request_data.headers.as_ref())?;
-    hash.aset(*KEY_HEADERS, headers)?;
+    if let Some(exception) = err.value() {
+        if matches!(exception.respond_to("status", false), Ok(true)) {
+            if let Ok(code) = exception.funcall::<_, _, i64>("status", ()) {
+                status = StatusCode::from_u16(code as u16).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+            }
+        } else if matches!(exception.respond_to("status_code", false), Ok(true))
+            && let Ok(code) = exception.funcall::<_, _, i64>("status_code", ())
+        {
+            status = StatusCode::from_u16(code as u16).unwrap_or(StatusCode::INTERNAL_SERVER_ERROR);
+        }
 
-    let cookies = map_to_ruby_hash(ruby, request_data.cookies.as_ref())?;
-    hash.aset(*KEY_COOKIES, cookies)?;
+        let json_module = handler.json_module.get_inner_with(ruby);
+        if matches!(exception.respond_to("code", false), Ok(true))
+            && let Ok(value) = exception.funcall::<_, _, Value>("code", ())
+            && let Ok(json_value) = ruby_value_to_json(ruby, json_module, value)
+        {
+            extensions.insert("code".to_string(), json_value);
+        }
 
-    let upload_class_value = handler.upload_file_class.as_ref().map(|cls| cls.get_inner_with(ruby));
-    let body_value = json_to_ruby_with_uploads(ruby, &request_data.body, upload_class_value.as_ref())?;
-    hash.aset(*KEY_BODY, body_value)?;
-    if let Some(raw) = &request_data.raw_body {
-        let raw_str = ruby.str_from_slice(raw);
-        hash.aset(*KEY_RAW_BODY, raw_str)?;
-    } else {
-        hash.aset(*KEY_RAW_BODY, ruby.qnil())?;
+        if matches!(exception.respond_to("details", false), Ok(true))
+            && let Ok(value) = exception.funcall::<_, _, Value>("details", ())
+            && let Ok(json_value) = ruby_value_to_json(ruby, json_module, value)
+        {
+            extensions.insert("details".to_string(), json_value);
+        }
     }
 
-    let params_value = if let Some(validated) = validated_params {
-        json_to_ruby(ruby, validated)?
-    } else {
-        build_default_params_from_converted(ruby, path_params, query_value, headers, cookies)?
-    };
-    hash.aset(*KEY_PARAMS, params_value)?;
+    detail = sanitize_error_detail(&detail);
+
+    let mut problem = problem_for_status(status, detail);
+    for (key, value) in extensions {
+        problem = problem.with_extension(key, value);
+    }
 
-    Ok(hash.as_value())
+    ErrorResponseBuilder::problem_details_response(&problem)
 }
 
-/// Build default params from already converted Ruby values, avoiding double conversion.
-fn build_default_params_from_converted(
-    ruby: &Ruby,
-    path_params: Value,
-    query: Value,
-    headers: Value,
-    cookies: Value,
-) -> Result<Value, Error> {
-    let params = ruby.hash_new();
-
-    if let Some(hash) = RHash::from_value(path_params) {
-        let _: Value = params.funcall("merge!", (hash,))?;
-    }
-    if let Some(hash) = RHash::from_value(query) {
-        let _: Value = params.funcall("merge!", (hash,))?;
+fn ruby_error_message(_ruby: &Ruby, err: &Error) -> String {
+    if let Some(exception) = err.value()
+        && matches!(exception.respond_to("message", false), Ok(true))
+        && let Ok(message) = exception.funcall::<_, _, String>("message", ())
+    {
+        return message;
     }
-    if let Some(hash) = RHash::from_value(headers) {
-        let _: Value = params.funcall("merge!", (hash,))?;
+    err.to_string()
+}
+
+fn problem_for_status(status: StatusCode, detail: String) -> ProblemDetails {
+    match status {
+        StatusCode::BAD_REQUEST => ProblemDetails::bad_request(detail),
+        StatusCode::UNAUTHORIZED => {
+            ProblemDetails::new("https://spikard.dev/errors/unauthorized", "Unauthorized", status).with_detail(detail)
+        }
+        StatusCode::FORBIDDEN => {
+            ProblemDetails::new("https://spikard.dev/errors/forbidden", "Forbidden", status).with_detail(detail)
+        }
+        StatusCode::NOT_FOUND => ProblemDetails::not_found(detail),
+        StatusCode::UNPROCESSABLE_ENTITY => ProblemDetails::new(
+            ProblemDetails::TYPE_VALIDATION_ERROR,
+            "Request Validation Failed",
+            status,
+        )
+        .with_detail(detail),
+        _ => ProblemDetails::internal_server_error(detail),
     }
-    if let Some(hash) = RHash::from_value(cookies) {
-        let _: Value = params.funcall("merge!", (hash,))?;
+}
+
+fn sanitize_error_detail(detail: &str) -> String {
+    let mut tokens = Vec::new();
+    let mut redact_next = false;
+
+    for token in detail.split_whitespace() {
+        let lower = token.to_lowercase();
+        if token.starts_with('/') || token.contains(".rb:") {
+            tokens.push("[redacted]".to_string());
+            redact_next = false;
+            continue;
+        }
+
+        if lower.starts_with("password=") {
+            tokens.push("password=[redacted]".to_string());
+            redact_next = false;
+            continue;
+        }
+
+        if lower.starts_with("host=") {
+            tokens.push("host=[redacted]".to_string());
+            redact_next = false;
+            continue;
+        }
+
+        if lower.starts_with("token=") || lower.starts_with("secret=") {
+            tokens.push("[redacted]".to_string());
+            redact_next = false;
+            continue;
+        }
+
+        if redact_next {
+            tokens.push("[redacted]".to_string());
+            redact_next = false;
+            continue;
+        }
+
+        if token.eq_ignore_ascii_case("in") {
+            tokens.push(token.to_string());
+            redact_next = true;
+            continue;
+        }
+
+        tokens.push(token.to_string());
     }
 
-    Ok(params.as_value())
+    let mut sanitized = tokens.join(" ");
+    sanitized = sanitized.replace("SELECT *", "[redacted]");
+    sanitized = sanitized.replace("select *", "[redacted]");
+    sanitized = sanitized.replace("FROM users", "[redacted]");
+    sanitized = sanitized.replace("from users", "[redacted]");
+    sanitized
 }
 
 /// Interpret a Ruby handler response into our response types.