spikard 0.8.1 → 0.8.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2e00c3157cc5b1a3971cf534263f4a554953b29aba028d681a4641cc6eea6e7f
-  data.tar.gz: 78f3c47e532447c265ae0bee25cc01317000549c7b811685ba9e648229541b4b
+  metadata.gz: 812ea62c2af7b3d443a8485aa055c197cdb1b65b04a3cc916ffd7bd6b0dfc81a
+  data.tar.gz: 825b7329c8ce47f3d74ebcc97fdbfa5ebbd5cbc16294b2721362bc1bd62fc7c6
 SHA512:
-  metadata.gz: 4e998981f0096716f4f3248773d9f06ab87c3c6fef18cb66a12e30c47893e48775d98000480361be14b6f46c098edca727c30e324a84951585a0f0b9119ee107
-  data.tar.gz: eb400d4510cfa5a9c7d489feba501e9acbea43f09b5c412cea001c1ed710d149801b6d8caf014f8f2ed2675f2b525d6eafbb3a785729e6510b87e692ded6a11c
+  metadata.gz: 8c27c069e2a10c5dc6b43f721f5baf2c56f5361f3fde3362b7ee3242b0deda62d9e4f198853cbba3e3f44c5f7aa0028495623961299fa99cc9bc9518d6f726a6
+  data.tar.gz: 6179700d82a1aff3aa93b87ac1152be28722eda2559a8becd8946d3e462cd32acc73328154c4906b79fab39e0188f0e7d84fefaa0e2aa4cc18358bb0fec6a84e

data/ext/spikard_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-ext"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2024"
 license = "MIT"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]

data/lib/spikard/grpc.rb

@@ -42,10 +42,12 @@ module Spikard
     #   @return [String] Binary string containing serialized protobuf message
     # @!attribute [r] metadata
     #   @return [Hash<String, String>] gRPC metadata (headers)
+    # rubocop:disable Lint/EmptyClass -- Implementation in Rust via FFI
     class Request
-      # These methods are implemented in Rust via Magnus FFI
-      # See: crates/spikard-rb/src/grpc/handler.rs
+      # These methods are implemented in Rust via Magnus FFI.
+      # See: crates/spikard-rb/src/grpc/handler.rs for implementation details.
     end
+    # rubocop:enable Lint/EmptyClass
 
     # gRPC response object
     #
@@ -148,9 +150,7 @@ module Spikard
       def register_handler(service_name, handler)
         raise ArgumentError, 'Service name cannot be empty' if service_name.nil? || service_name.empty?
 
-        unless handler.respond_to?(:handle_request)
-          raise ArgumentError, "Handler must respond to :handle_request"
-        end
+        raise ArgumentError, 'Handler must respond to :handle_request' unless handler.respond_to?(:handle_request)
 
         @handlers[service_name] = handler
       end

data/lib/spikard/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Spikard
-  VERSION = '0.8.1'
+  VERSION = '0.8.2'
 end

data/vendor/crates/spikard-bindings-shared/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-bindings-shared"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"

data/vendor/crates/spikard-bindings-shared/src/grpc_metadata.rs

@@ -4,7 +4,7 @@
 //! language bindings (Python, Node.js, Ruby, PHP) to avoid code duplication.
 
 use std::collections::HashMap;
-use tonic::metadata::{MetadataMap, MetadataKey, MetadataValue};
+use tonic::metadata::{MetadataKey, MetadataMap, MetadataValue};
 
 /// Extract metadata from gRPC MetadataMap to a simple HashMap.
 ///
@@ -94,8 +94,8 @@ pub fn hashmap_to_metadata(map: &HashMap<String, String>) -> Result<MetadataMap,
         let metadata_key = MetadataKey::from_bytes(key.as_bytes())
             .map_err(|err| format!("Invalid metadata key '{}': {}", key, err))?;
 
-        let metadata_value = MetadataValue::try_from(value)
-            .map_err(|err| format!("Invalid metadata value for '{}': {}", key, err))?;
+        let metadata_value =
+            MetadataValue::try_from(value).map_err(|err| format!("Invalid metadata value for '{}': {}", key, err))?;
 
         metadata.insert(metadata_key, metadata_value);
     }

data/vendor/crates/spikard-core/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-core"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"

data/vendor/crates/spikard-core/src/metadata.rs

@@ -181,11 +181,7 @@ pub fn parse_parameter_schema(schema: &Value) -> Result<Vec<ParameterMetadata>,
     let required: Vec<String> = schema
         .get("required")
         .and_then(|r| r.as_array())
-        .map(|arr| {
-            arr.iter()
-                .filter_map(|v| v.as_str().map(String::from))
-                .collect()
-        })
+        .map(|arr| arr.iter().filter_map(|v| v.as_str().map(String::from)).collect())
         .unwrap_or_default();
 
     for (param_name, param_schema) in props {
@@ -197,10 +193,7 @@ pub fn parse_parameter_schema(schema: &Value) -> Result<Vec<ParameterMetadata>,
             .and_then(|s| s.parse().ok())
             .unwrap_or(ParameterSource::Query);
 
-        let schema_type = param_schema
-            .get("type")
-            .and_then(|t| t.as_str())
-            .map(String::from);
+        let schema_type = param_schema.get("type").and_then(|t| t.as_str()).map(String::from);
 
         params.push(ParameterMetadata {
             name: param_name.clone(),
@@ -242,11 +235,7 @@ pub fn validate_metadata(metadata: &ExtractedRouteMetadata) -> Result<(), Vec<St
         }
     }
 
-    if errors.is_empty() {
-        Ok(())
-    } else {
-        Err(errors)
-    }
+    if errors.is_empty() { Ok(()) } else { Err(errors) }
 }
 
 /// Merge path parameters with parameter schema

data/vendor/crates/spikard-http/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-http"
-version = "0.8.1"
+version = "0.8.2"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"

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

@@ -48,7 +48,7 @@ pub mod streaming;
 
 // Re-export main types
 pub use handler::{GrpcHandler, GrpcHandlerResult, GrpcRequestData, GrpcResponseData};
-pub use service::{copy_metadata, GenericGrpcService, is_grpc_request, parse_grpc_path};
+pub use service::{GenericGrpcService, copy_metadata, is_grpc_request, parse_grpc_path};
 pub use streaming::{MessageStream, StreamingRequest, StreamingResponse};
 
 use serde::{Deserialize, Serialize};

data/vendor/crates/spikard-http/src/grpc/service.rs

@@ -200,7 +200,9 @@ mod tests {
         let service = GenericGrpcService::new(handler);
 
         let request = Request::new(Bytes::from("test payload"));
-        let result = service.handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request).await;
+        let result = service
+            .handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request)
+            .await;
 
         assert!(result.is_ok());
         let response = result.unwrap();
@@ -217,7 +219,9 @@ mod tests {
             .metadata_mut()
             .insert("custom-header", "custom-value".parse().unwrap());
 
-        let result = service.handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request).await;
+        let result = service
+            .handle_unary("test.TestService".to_string(), "TestMethod".to_string(), request)
+            .await;
 
         assert!(result.is_ok());
     }
@@ -266,10 +270,7 @@ mod tests {
     #[test]
     fn test_is_grpc_request_valid() {
         let mut headers = axum::http::HeaderMap::new();
-        headers.insert(
-            axum::http::header::CONTENT_TYPE,
-            "application/grpc".parse().unwrap(),
-        );
+        headers.insert(axum::http::header::CONTENT_TYPE, "application/grpc".parse().unwrap());
         assert!(is_grpc_request(&headers));
     }
 
@@ -286,10 +287,7 @@ mod tests {
     #[test]
     fn test_is_grpc_request_not_grpc() {
         let mut headers = axum::http::HeaderMap::new();
-        headers.insert(
-            axum::http::header::CONTENT_TYPE,
-            "application/json".parse().unwrap(),
-        );
+        headers.insert(axum::http::header::CONTENT_TYPE, "application/json".parse().unwrap());
         assert!(!is_grpc_request(&headers));
     }
 
@@ -382,7 +380,9 @@ mod tests {
         let service = GenericGrpcService::new(handler);
 
         let request = Request::new(Bytes::new());
-        let result = service.handle_unary("test.ErrorService".to_string(), "ErrorMethod".to_string(), request).await;
+        let result = service
+            .handle_unary("test.ErrorService".to_string(), "ErrorMethod".to_string(), request)
+            .await;
 
         assert!(result.is_err());
         let status = result.unwrap_err();

data/vendor/crates/spikard-http/src/grpc/streaming.rs

@@ -193,7 +193,11 @@ mod tests {
 
     #[tokio::test]
     async fn test_from_tonic_stream() {
-        let messages = vec![Ok(Bytes::from("a")), Ok(Bytes::from("b")), Err(Status::cancelled("done"))];
+        let messages = vec![
+            Ok(Bytes::from("a")),
+            Ok(Bytes::from("b")),
+            Err(Status::cancelled("done")),
+        ];
 
         let tonic_stream = futures_util::stream::iter(messages);
         let mut stream = from_tonic_stream(tonic_stream);

data/vendor/crates/spikard-http/src/server/grpc_routing.rs

@@ -69,10 +69,7 @@ pub async fn route_grpc_request(
     let handler = match registry.get(&service_name) {
         Some(h) => h,
         None => {
-            return Err((
-                StatusCode::NOT_FOUND,
-                format!("Service not found: {}", service_name),
-            ));
+            return Err((StatusCode::NOT_FOUND, format!("Service not found: {}", service_name)));
         }
     };
 
@@ -94,7 +91,10 @@ pub async fn route_grpc_request(
             // Try to parse as ASCII metadata
             if let Ok(metadata_value) = value_str.parse::<tonic::metadata::MetadataValue<tonic::metadata::Ascii>>() {
                 // Use key.as_str() directly instead of creating String
-                if let Ok(metadata_key) = key.as_str().parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>() {
+                if let Ok(metadata_key) = key
+                    .as_str()
+                    .parse::<tonic::metadata::MetadataKey<tonic::metadata::Ascii>>()
+                {
                     tonic_request.metadata_mut().insert(metadata_key, metadata_value);
                 }
             }
@@ -132,9 +132,12 @@ pub async fn route_grpc_request(
     response = response.header("grpc-status", "0");
 
     // Convert bytes::Bytes to Body
-    let response = response
-        .body(Body::from(payload))
-        .map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, format!("Failed to build response: {}", e)))?;
+    let response = response.body(Body::from(payload)).map_err(|e| {
+        (
+            StatusCode::INTERNAL_SERVER_ERROR,
+            format!("Failed to build response: {}", e),
+        )
+    })?;
 
     Ok(response)
 }
@@ -268,21 +271,57 @@ mod tests {
     fn test_grpc_status_to_http_mappings() {
         // Test all gRPC status codes map correctly
         assert_eq!(grpc_status_to_http(tonic::Code::Ok), StatusCode::OK);
-        assert_eq!(grpc_status_to_http(tonic::Code::Cancelled), StatusCode::from_u16(499).unwrap());
-        assert_eq!(grpc_status_to_http(tonic::Code::Unknown), StatusCode::INTERNAL_SERVER_ERROR);
-        assert_eq!(grpc_status_to_http(tonic::Code::InvalidArgument), StatusCode::BAD_REQUEST);
-        assert_eq!(grpc_status_to_http(tonic::Code::DeadlineExceeded), StatusCode::GATEWAY_TIMEOUT);
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Cancelled),
+            StatusCode::from_u16(499).unwrap()
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unknown),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::InvalidArgument),
+            StatusCode::BAD_REQUEST
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::DeadlineExceeded),
+            StatusCode::GATEWAY_TIMEOUT
+        );
         assert_eq!(grpc_status_to_http(tonic::Code::NotFound), StatusCode::NOT_FOUND);
         assert_eq!(grpc_status_to_http(tonic::Code::AlreadyExists), StatusCode::CONFLICT);
-        assert_eq!(grpc_status_to_http(tonic::Code::PermissionDenied), StatusCode::FORBIDDEN);
-        assert_eq!(grpc_status_to_http(tonic::Code::ResourceExhausted), StatusCode::TOO_MANY_REQUESTS);
-        assert_eq!(grpc_status_to_http(tonic::Code::FailedPrecondition), StatusCode::BAD_REQUEST);
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::PermissionDenied),
+            StatusCode::FORBIDDEN
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::ResourceExhausted),
+            StatusCode::TOO_MANY_REQUESTS
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::FailedPrecondition),
+            StatusCode::BAD_REQUEST
+        );
         assert_eq!(grpc_status_to_http(tonic::Code::Aborted), StatusCode::CONFLICT);
         assert_eq!(grpc_status_to_http(tonic::Code::OutOfRange), StatusCode::BAD_REQUEST);
-        assert_eq!(grpc_status_to_http(tonic::Code::Unimplemented), StatusCode::NOT_IMPLEMENTED);
-        assert_eq!(grpc_status_to_http(tonic::Code::Internal), StatusCode::INTERNAL_SERVER_ERROR);
-        assert_eq!(grpc_status_to_http(tonic::Code::Unavailable), StatusCode::SERVICE_UNAVAILABLE);
-        assert_eq!(grpc_status_to_http(tonic::Code::DataLoss), StatusCode::INTERNAL_SERVER_ERROR);
-        assert_eq!(grpc_status_to_http(tonic::Code::Unauthenticated), StatusCode::UNAUTHORIZED);
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unimplemented),
+            StatusCode::NOT_IMPLEMENTED
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Internal),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unavailable),
+            StatusCode::SERVICE_UNAVAILABLE
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::DataLoss),
+            StatusCode::INTERNAL_SERVER_ERROR
+        );
+        assert_eq!(
+            grpc_status_to_http(tonic::Code::Unauthenticated),
+            StatusCode::UNAUTHORIZED
+        );
     }
 }