spikard 0.8.3 → 0.10.2

data/ext/spikard_rb/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-rb-ext"
-version = "0.8.3"
+version = "0.10.2"
 edition = "2024"
 license = "MIT"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
@@ -13,5 +13,5 @@ crate-type = ["cdylib"]
 
 [dependencies]
 magnus = { version = "0.8.2", features = ["rb-sys"] }
-# Use vendored crates for packaged gem distribution
+# Use crates from the workspace root
 spikard_rb_core = { package = "spikard-rb", path = "../../vendor/crates/spikard-rb" }

data/ext/spikard_rb/extconf.rb

@@ -7,7 +7,8 @@ default_profile = ENV.fetch('CARGO_PROFILE', 'release')
 
 create_rust_makefile('spikard_rb') do |config|
   config.profile = default_profile.to_sym
-  # Only use --locked in development to prevent lockfile updates
-  # Release builds need to update Cargo.lock after version bumps
-  config.extra_cargo_args = ['--locked'] unless default_profile == 'release'
+  # Always use --locked to maintain consistency with vendored crates.
+  # The vendor-crates.sh script patches Cargo.toml files and relies on a
+  # committed Cargo.lock to avoid workspace collision issues during builds.
+  config.extra_cargo_args = ['--locked']
 end

data/lib/spikard/config.rb

@@ -21,10 +21,34 @@ module Spikard
     # @param min_size [Integer] Minimum response size in bytes to compress (default: 1024)
     # @param quality [Integer] Compression quality level (0-11 for brotli, 0-9 for gzip, default: 6)
     def initialize(gzip: true, brotli: true, min_size: 1024, quality: 6)
-      @gzip = gzip
-      @brotli = brotli
-      @min_size = min_size
-      @quality = quality
+      @gzip = normalize_boolean('gzip', gzip)
+      @brotli = normalize_boolean('brotli', brotli)
+      @min_size = normalize_nonnegative_integer('min_size', min_size)
+      @quality = normalize_quality(quality)
+    end
+
+    private
+
+    def normalize_boolean(name, value)
+      return value if [true, false].include?(value)
+
+      raise ArgumentError, "#{name} must be a boolean"
+    end
+
+    def normalize_nonnegative_integer(name, value)
+      raise ArgumentError, "#{name} must be an Integer" unless value.is_a?(Integer)
+      return value if value >= 0
+
+      raise ArgumentError, "#{name} must be >= 0"
+    end
+
+    def normalize_quality(value)
+      raise ArgumentError, 'quality must be a number' unless value.is_a?(Integer) || value.is_a?(Float)
+
+      normalized = value.to_i
+      return normalized if normalized.between?(0, 11)
+
+      raise ArgumentError, 'quality must be between 0 and 11'
     end
   end
 
@@ -378,19 +402,71 @@ module Spikard
       openapi: nil
     )
       @host = host
-      @port = port
-      @workers = workers
-      @enable_request_id = enable_request_id
-      @max_body_size = max_body_size
-      @request_timeout = request_timeout
+      @port = normalize_port(port)
+      @workers = normalize_workers(workers)
+      @enable_request_id = normalize_boolean('enable_request_id', enable_request_id)
+      @max_body_size = normalize_optional_nonnegative_integer('max_body_size', max_body_size)
+      @request_timeout = normalize_timeout('request_timeout', request_timeout)
       @compression = compression
       @rate_limit = rate_limit
       @jwt_auth = jwt_auth
       @api_key_auth = api_key_auth
-      @static_files = static_files
-      @graceful_shutdown = graceful_shutdown
-      @shutdown_timeout = shutdown_timeout
+      @static_files = normalize_static_files(static_files)
+      @graceful_shutdown = normalize_boolean('graceful_shutdown', graceful_shutdown)
+      @shutdown_timeout = normalize_timeout('shutdown_timeout', shutdown_timeout)
       @openapi = openapi
     end
+
+    private
+
+    def normalize_port(port)
+      raise ArgumentError, 'port must be an Integer' unless port.is_a?(Integer)
+      return port if port.between?(1, 65_535)
+
+      raise ArgumentError, 'port must be between 1 and 65535'
+    end
+
+    def normalize_workers(workers)
+      raise ArgumentError, 'workers must be an Integer' unless workers.is_a?(Integer)
+      return workers if workers >= 1
+
+      raise ArgumentError, 'workers must be >= 1'
+    end
+
+    def normalize_boolean(name, value)
+      return value if [true, false].include?(value)
+
+      raise ArgumentError, "#{name} must be a boolean"
+    end
+
+    def normalize_optional_nonnegative_integer(name, value)
+      return nil if value.nil?
+      raise ArgumentError, "#{name} must be an Integer" unless value.is_a?(Integer)
+      return value if value >= 0
+
+      raise ArgumentError, "#{name} must be >= 0"
+    end
+
+    def normalize_timeout(name, value)
+      return nil if value.nil?
+      raise ArgumentError, "#{name} must be a number" unless value.is_a?(Integer) || value.is_a?(Float)
+
+      normalized = value.to_i
+      return normalized if normalized >= 0
+
+      raise ArgumentError, "#{name} must be >= 0"
+    end
+
+    def normalize_static_files(static_files)
+      return [] if static_files.nil?
+      raise ArgumentError, 'static_files must be an Array' unless static_files.is_a?(Array)
+
+      static_files.each do |entry|
+        next if entry.is_a?(StaticFilesConfig)
+
+        raise ArgumentError, 'static_files entries must be StaticFilesConfig'
+      end
+      static_files
+    end
   end
 end

data/lib/spikard/testing.rb

@@ -38,8 +38,10 @@ module Spikard
       handlers = app.handler_map.transform_keys(&:to_sym)
       ws_handlers = app.websocket_handlers || {}
       sse_producers = app.sse_producers || {}
+      hooks = app.instance_variable_get(:@native_hooks)
       dependencies = app.dependencies || {}
-      Spikard::Native::TestClient.new(routes_json, handlers, config, ws_handlers, sse_producers, dependencies)
+      payload = { hooks: hooks, dependencies: dependencies }
+      Spikard::Native::TestClient.new(routes_json, handlers, config, ws_handlers, sse_producers, payload)
     end
 
     # High level wrapper around the native test client.

data/lib/spikard/version.rb

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

data/lib/spikard.rb

@@ -34,6 +34,17 @@ rescue LoadError => e
   MSG
 end
 
+if defined?(Spikard::Native::TestClient) && !Spikard::Native::TestClient.method_defined?(:__spikard_native_request,
+                                                                                         false)
+  Spikard::Native::TestClient.class_eval do
+    alias_method :__spikard_native_request, :request
+
+    def request(method, path, options = nil)
+      __spikard_native_request(method, path, options)
+    end
+  end
+end
+
 # Convenience aliases and methods at top level
 module Spikard
   TestClient = Testing::TestClient

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

@@ -1,6 +1,6 @@
 [package]
 name = "spikard-bindings-shared"
-version = "0.8.3"
+version = "0.10.2"
 edition = "2024"
 authors = ["Na'aman Hirschfeld <nhirschfeld@gmail.com>"]
 license = "MIT"
@@ -18,6 +18,7 @@ nursery = { level = "deny", priority = 0 }
 [dependencies]
 serde = { version = "1.0", features = ["derive"] }
 serde_json = "1.0"
+simd-json = "0.17"
 axum = { version = "0.8", features = ["multipart", "ws"] }
 tokio = { version = "1", features = ["full"] }
 thiserror = "2.0"
@@ -27,6 +28,7 @@ tracing = "0.1"
 http = "1.4"
 http-body-util = "0.1"
 tonic = "0.14"
+bytes = "1.11"
 
 [features]
 default = []
@@ -34,7 +36,6 @@ python-support = ["pyo3", "pyo3-async-runtimes"]
 node-support = ["napi", "napi-derive"]
 ruby-support = ["magnus"]
 php-support = ["ext-php-rs"]
-wasm-support = ["wasm-bindgen"]
 
 [dependencies.pyo3]
 version = "0.27"
@@ -64,9 +65,5 @@ optional = true
 version = "0.15"
 optional = true
 
-[dependencies.wasm-bindgen]
-version = "0.2"
-optional = true
-
 [dev-dependencies]
 pretty_assertions = "1.4"

data/vendor/crates/spikard-bindings-shared/examples/config_extraction.rs

@@ -1,12 +1,12 @@
-//! Example of implementing ConfigSource for a language binding
+//! Example of implementing `ConfigSource` for a language binding
 //!
 //! This example demonstrates how a language binding (e.g., Python, Node.js, Ruby, PHP)
-//! would implement the `ConfigSource` trait to extract ServerConfig from language-specific objects.
+//! would implement the `ConfigSource` trait to extract `ServerConfig` from language-specific objects.
 
 use spikard_bindings_shared::{ConfigExtractor, ConfigSource};
 use std::collections::HashMap;
 
-/// Example: PyO3 Python dict wrapper
+/// Example: `PyO3` Python dict wrapper
 struct PyDictWrapper {
     data: HashMap<String, String>,
 }
@@ -74,7 +74,7 @@ fn main() {
             println!("   min_size: {}", config.min_size);
             println!("   quality: {}\n", config.quality);
         }
-        Err(e) => println!("   Error: {}\n", e),
+        Err(e) => println!("   Error: {e}\n"),
     }
 
     println!("2. Extracting JWT authentication configuration:");
@@ -89,7 +89,7 @@ fn main() {
             println!("   algorithm: {}", config.algorithm);
             println!("   leeway: {}\n", config.leeway);
         }
-        Err(e) => println!("   Error: {}\n", e),
+        Err(e) => println!("   Error: {e}\n"),
     }
 
     println!("3. Extracting API Key authentication configuration:");
@@ -102,7 +102,7 @@ fn main() {
             println!("   keys: {:?}", config.keys);
             println!("   header_name: {}\n", config.header_name);
         }
-        Err(e) => println!("   Error: {}\n", e),
+        Err(e) => println!("   Error: {e}\n"),
     }
 
     println!("4. Extracting rate limit configuration:");
@@ -117,7 +117,7 @@ fn main() {
             println!("   burst: {}", config.burst);
             println!("   ip_based: {}\n", config.ip_based);
         }
-        Err(e) => println!("   Error: {}\n", e),
+        Err(e) => println!("   Error: {e}\n"),
     }
 
     println!("5. Testing error handling (missing 'burst' field):");
@@ -125,7 +125,7 @@ fn main() {
 
     match ConfigExtractor::extract_rate_limit_config(&rate_limit_config) {
         Ok(_config) => println!("   Success (unexpected!)"),
-        Err(e) => println!("   Expected error: {}\n", e),
+        Err(e) => println!("   Expected error: {e}\n"),
     }
 
     println!("=== Example Complete ===");

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

@@ -587,7 +587,7 @@ mod tests {
         assert_eq!(config.port, 3000);
         assert_eq!(config.workers, 4);
         assert!(!config.enable_request_id);
-        assert_eq!(config.max_body_size, Some(5242880));
+        assert_eq!(config.max_body_size, Some(5_242_880));
         assert_eq!(config.request_timeout, Some(60));
         assert!(!config.graceful_shutdown);
         assert_eq!(config.shutdown_timeout, 10);
@@ -620,7 +620,7 @@ mod tests {
     fn test_security_schemes_config_empty() {
         let source = MockConfigSource::new();
 
-        let schemes = ConfigExtractor::extract_security_schemes_config(&source).unwrap();
+        let schemes = ConfigExtractor::extract_security_schemes_config(&source);
         assert_eq!(schemes.len(), 0);
     }
 

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

@@ -87,7 +87,7 @@ mod tests {
         fn from_any(value: &(dyn Any + Send + Sync)) -> Result<Self, Self::Error> {
             value
                 .downcast_ref::<i32>()
-                .map(|&v| TestType { value: v })
+                .map(|&v| Self { value: v })
                 .ok_or_else(|| "Invalid type".to_string())
         }
     }
@@ -169,7 +169,7 @@ mod tests {
     #[test]
     fn test_json_null_conversion() {
         let null_value = serde_json::Value::Null;
-        let result = serde_json::Value::from_json(null_value.clone());
+        let result = serde_json::Value::from_json(null_value);
         assert!(result.is_ok());
         assert!(result.unwrap().is_null());
     }
@@ -177,7 +177,7 @@ mod tests {
     #[test]
     fn test_json_array_conversion() {
         let array = json!([1, 2, 3, 4, 5]);
-        let result = serde_json::Value::from_json(array.clone());
+        let result = serde_json::Value::from_json(array);
         assert!(result.is_ok());
         let converted = result.unwrap();
         assert!(converted.is_array());
@@ -196,7 +196,7 @@ mod tests {
             }
         });
 
-        let result = serde_json::Value::from_json(nested.clone());
+        let result = serde_json::Value::from_json(nested);
         assert!(result.is_ok());
         let converted = result.unwrap();
         assert_eq!(converted["level1"]["level2"]["level3"]["value"], "deep");

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

@@ -19,21 +19,21 @@ type DependencyFuture<'a> =
 /// Adapter trait for value dependencies across language bindings
 ///
 /// Language bindings should implement this trait to wrap their
-/// language-specific value storage (e.g., Py<PyAny>, Opaque<Value>, etc.)
+/// language-specific value storage (e.g., `Py<PyAny>`, `Opaque<Value>`, etc.)
 pub trait ValueDependencyAdapter: Send + Sync {
     /// Get the dependency key
     fn key(&self) -> &str;
 
     /// Resolve the stored value
     ///
-    /// Returns an Arc<dyn Any> that can be downcast to the concrete type
+    /// Returns an `Arc<dyn Any>` that can be downcast to the concrete type
     fn resolve_value(&self) -> DependencyFuture<'_>;
 }
 
 /// Adapter trait for factory dependencies across language bindings
 ///
 /// Language bindings should implement this trait to wrap their
-/// language-specific callable storage (e.g., Py<PyAny>, `ThreadsafeFunction`, etc.)
+/// language-specific callable storage (e.g., `Py<PyAny>`, `ThreadsafeFunction`, etc.)
 pub trait FactoryDependencyAdapter: Send + Sync {
     /// Get the dependency key
     fn key(&self) -> &str;
@@ -41,7 +41,7 @@ pub trait FactoryDependencyAdapter: Send + Sync {
     /// Invoke the factory with resolved dependencies
     ///
     /// The factory receives already-resolved dependencies and returns
-    /// a new instance wrapped in Arc<dyn Any>
+    /// a new instance wrapped in `Arc<dyn Any>`
     fn invoke_factory(
         &self,
         request: &Request<()>,
@@ -81,6 +81,9 @@ impl<T: ValueDependencyAdapter + 'static> Dependency for ValueDependencyBridge<T
         self.adapter.key()
     }
 
+    // PERFORMANCE: Value dependencies have no sub-dependencies.
+    // Returning an empty Vec is unavoidable if the trait requires it, but
+    // consider optimizing the DI system to use Option<&[String]> or a default method.
     fn depends_on(&self) -> Vec<String> {
         vec![]
     }
@@ -114,6 +117,9 @@ impl<T: FactoryDependencyAdapter + 'static> Dependency for FactoryDependencyBrid
         self.adapter.key()
     }
 
+    // PERFORMANCE: Factory dependencies may or may not have sub-dependencies.
+    // Language bindings should override this if they track dependencies.
+    // The default empty Vec is acceptable for language bindings that don't track explicit dependency graphs.
     fn depends_on(&self) -> Vec<String> {
         vec![]
     }

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

@@ -260,7 +260,7 @@ mod tests {
             StatusCode::BAD_REQUEST,
             "validation_error",
             "Invalid email format",
-            details.clone(),
+            details,
         );
         assert_eq!(status, StatusCode::BAD_REQUEST);
         let parsed: Value = serde_json::from_str(&body).unwrap();
@@ -273,7 +273,7 @@ mod tests {
     #[test]
     fn test_from_structured_error() {
         let error = StructuredError::simple("test_error", "Something went wrong");
-        let (status, body) = ErrorResponseBuilder::from_structured_error(error);
+        let (status, body) = ErrorResponseBuilder::from_structured_error(&error);
         assert_eq!(status, StatusCode::INTERNAL_SERVER_ERROR);
         let parsed: Value = serde_json::from_str(&body).unwrap();
         assert_eq!(parsed["code"], "test_error");
@@ -287,7 +287,7 @@ mod tests {
                 error_type: "missing".to_string(),
                 loc: vec!["body".to_string(), "username".to_string()],
                 msg: "Field required".to_string(),
-                input: Value::String("".to_string()),
+                input: Value::String(String::new()),
                 ctx: None,
             }],
         };

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

@@ -33,7 +33,9 @@ pub enum HandlerError {
 
 impl From<ValidationError> for HandlerError {
     fn from(err: ValidationError) -> Self {
-        Self::Validation(format!("{err:?}"))
+        // PERFORMANCE: Avoid format! allocation for debug representation.
+        // Most callers just need the error type, not the full debug output.
+        Self::Validation(err.to_string())
     }
 }
 
@@ -125,6 +127,9 @@ impl<L: LanguageHandler + 'static> Handler for HandlerExecutor<L> {
                 return Err(ErrorResponseBuilder::validation_error(&validation_err));
             }
 
+            // PERFORMANCE: Avoid format! allocations in the hot path. ErrorResponseBuilder
+            // can accept &dyn Display or construct error messages directly, reducing
+            // string allocation overhead in typical error handling paths.
             let input = self
                 .language_handler
                 .prepare_request(&request_data)
@@ -181,10 +186,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(std::collections::HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(std::collections::HashMap::new()),
-            body: json!({}),
+            body: Arc::new(json!({})),
             raw_body: None,
             headers: Arc::new(std::collections::HashMap::new()),
             cookies: Arc::new(std::collections::HashMap::new()),
@@ -205,10 +210,10 @@ mod tests {
         let request = Request::builder().body(Body::empty()).unwrap();
         let request_data = RequestData {
             path_params: Arc::new(std::collections::HashMap::new()),
-            query_params: json!({}),
+            query_params: Arc::new(json!({})),
             validated_params: None,
             raw_query_params: Arc::new(std::collections::HashMap::new()),
-            body: json!({}),
+            body: Arc::new(json!({})),
             raw_body: None,
             headers: Arc::new(std::collections::HashMap::new()),
             cookies: Arc::new(std::collections::HashMap::new()),