@zap-js/server 0.0.1 → 0.0.4

package/src/request.rs

@@ -1,60 +0,0 @@
-//! Request types and utilities for ZapServer
-
-use std::collections::HashMap;
-use zap_core::{Request, Method};
-
-/// Request data that can be owned and moved between threads
-#[derive(Debug, Clone)]
-pub struct RequestData {
-    pub method: Method,
-    pub path: String,
-    pub path_only: String,
-    pub version: String,
-    pub headers: HashMap<String, String>,
-    pub body: Vec<u8>,
-    pub params: HashMap<String, String>,
-    pub query: HashMap<String, String>,
-    pub cookies: HashMap<String, String>,
-}
-
-impl RequestData {
-    /// Create RequestData from a borrowed Request
-    pub fn from_request(req: &Request) -> Self {
-        Self {
-            method: req.method(),
-            path: req.path().to_string(),
-            path_only: req.path_only().to_string(),
-            version: req.version().to_string(),
-            headers: req.headers().iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
-            body: req.body().to_vec(),
-            params: req.params().iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
-            query: req.query_params().into_iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
-            cookies: req.cookies().into_iter().map(|(k, v)| (k.to_string(), v.to_string())).collect(),
-        }
-    }
-    
-    /// Get parameter by name
-    pub fn param(&self, name: &str) -> Option<&str> {
-        self.params.get(name).map(|s| s.as_str())
-    }
-    
-    /// Get query parameter by name
-    pub fn query(&self, name: &str) -> Option<&str> {
-        self.query.get(name).map(|s| s.as_str())
-    }
-    
-    /// Get header by name
-    pub fn header(&self, name: &str) -> Option<&str> {
-        self.headers.get(name).map(|s| s.as_str())
-    }
-    
-    /// Get cookie by name
-    pub fn cookie(&self, name: &str) -> Option<&str> {
-        self.cookies.get(name).map(|s| s.as_str())
-    }
-    
-    /// Get body as string
-    pub fn body_string(&self) -> Result<String, std::string::FromUtf8Error> {
-        String::from_utf8(self.body.clone())
-    }
-} 

package/src/request_id.rs

@@ -1,97 +0,0 @@
-//! Request ID generation and extraction for request correlation
-//!
-//! Provides unique identifiers for each request that flow through
-//! the entire system (Rust server -> IPC -> TypeScript handlers).
-//! This enables end-to-end request tracing in logs and metrics.
-
-use uuid::Uuid;
-
-/// Standard header name for request ID
-pub const REQUEST_ID_HEADER: &str = "x-request-id";
-
-/// Generate a new UUID v4 request ID
-#[inline]
-pub fn generate() -> String {
-    Uuid::new_v4().to_string()
-}
-
-/// Extract request ID from headers or generate a new one
-///
-/// Checks for both lowercase and mixed-case header names.
-pub fn get_or_generate(headers: &std::collections::HashMap<String, String>) -> String {
-    // Check lowercase first (normalized headers)
-    if let Some(id) = headers.get(REQUEST_ID_HEADER) {
-        if !id.is_empty() {
-            return id.clone();
-        }
-    }
-
-    // Check mixed-case variant
-    if let Some(id) = headers.get("X-Request-ID") {
-        if !id.is_empty() {
-            return id.clone();
-        }
-    }
-
-    // Check another common variant
-    if let Some(id) = headers.get("X-Request-Id") {
-        if !id.is_empty() {
-            return id.clone();
-        }
-    }
-
-    generate()
-}
-
-/// Validate that a request ID looks reasonable
-/// (not empty, not too long, alphanumeric + hyphens)
-pub fn is_valid(id: &str) -> bool {
-    if id.is_empty() || id.len() > 128 {
-        return false;
-    }
-
-    id.chars()
-        .all(|c| c.is_ascii_alphanumeric() || c == '-' || c == '_')
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn test_generate_unique() {
-        let id1 = generate();
-        let id2 = generate();
-        assert_ne!(id1, id2);
-        assert!(is_valid(&id1));
-        assert!(is_valid(&id2));
-    }
-
-    #[test]
-    fn test_get_or_generate_extracts() {
-        let mut headers = std::collections::HashMap::new();
-        headers.insert("x-request-id".to_string(), "test-123".to_string());
-
-        let id = get_or_generate(&headers);
-        assert_eq!(id, "test-123");
-    }
-
-    #[test]
-    fn test_get_or_generate_creates() {
-        let headers = std::collections::HashMap::new();
-        let id = get_or_generate(&headers);
-        assert!(is_valid(&id));
-        // Should be UUID format
-        assert!(id.contains('-'));
-    }
-
-    #[test]
-    fn test_is_valid() {
-        assert!(is_valid("abc-123"));
-        assert!(is_valid("550e8400-e29b-41d4-a716-446655440000"));
-        assert!(is_valid("request_123"));
-        assert!(!is_valid(""));
-        assert!(!is_valid(&"a".repeat(200)));
-        assert!(!is_valid("test@123")); // @ not allowed
-    }
-}

package/src/response.rs

@@ -1,182 +0,0 @@
-//! Response types and utilities for ZapServer
-
-use std::collections::HashMap;
-use std::path::PathBuf;
-
-use bytes::Bytes;
-use serde::Serialize;
-
-use zap_core::{Response, StatusCode, ResponseBody};
-
-/// Streaming response data
-#[derive(Debug)]
-pub struct StreamingResponse {
-    /// HTTP status code
-    pub status: u16,
-    /// Response headers
-    pub headers: HashMap<String, String>,
-    /// Collected body chunks (base64 decoded)
-    pub chunks: Vec<Vec<u8>>,
-}
-
-impl StreamingResponse {
-    /// Create a new streaming response
-    pub fn new(status: u16, headers: HashMap<String, String>) -> Self {
-        Self {
-            status,
-            headers,
-            chunks: Vec::new(),
-        }
-    }
-
-    /// Add a chunk to the response
-    pub fn add_chunk(&mut self, data: Vec<u8>) {
-        self.chunks.push(data);
-    }
-
-    /// Get the complete body as bytes
-    pub fn body_bytes(&self) -> Vec<u8> {
-        let total_len: usize = self.chunks.iter().map(|c| c.len()).sum();
-        let mut body = Vec::with_capacity(total_len);
-        for chunk in &self.chunks {
-            body.extend_from_slice(chunk);
-        }
-        body
-    }
-
-    /// Get the complete body as a string (lossy conversion)
-    pub fn body_string(&self) -> String {
-        String::from_utf8_lossy(&self.body_bytes()).to_string()
-    }
-}
-
-/// Zap response types with auto-serialization
-#[derive(Debug)]
-pub enum ZapResponse {
-    /// Plain text response
-    Text(String),
-    /// HTML response
-    Html(String),
-    /// JSON response (auto-serialized)
-    Json(serde_json::Value),
-    /// JSON response with custom status code
-    JsonWithStatus(serde_json::Value, u16),
-    /// Binary response
-    Bytes(Bytes),
-    /// File response
-    File(PathBuf),
-    /// Custom response with full control
-    Custom(Response),
-    /// Redirect response
-    Redirect(String),
-    /// Empty response with status code
-    Status(StatusCode),
-    /// Streaming response (collected chunks)
-    Stream(StreamingResponse),
-}
-
-/// JSON response wrapper for auto-serialization
-#[derive(Debug)]
-pub struct Json<T>(pub T);
-
-impl<T: Serialize> From<Json<T>> for ZapResponse {
-    fn from(json: Json<T>) -> Self {
-        match serde_json::to_value(json.0) {
-            Ok(value) => ZapResponse::Json(value),
-            Err(_) => ZapResponse::Custom(
-                Response::internal_server_error("Failed to serialize JSON"),
-            ),
-        }
-    }
-}
-
-impl ZapResponse {
-    /// Convert ZapResponse to hyper Response
-    pub fn to_hyper_response(&self) -> hyper::Response<String> {
-        match self {
-            ZapResponse::Text(text) => hyper::Response::builder()
-                .status(200)
-                .header("Content-Type", "text/plain; charset=utf-8")
-                .body(text.clone())
-                .unwrap(),
-            ZapResponse::Html(html) => hyper::Response::builder()
-                .status(200)
-                .header("Content-Type", "text/html; charset=utf-8")
-                .body(html.clone())
-                .unwrap(),
-            ZapResponse::Json(json) => {
-                let body = serde_json::to_string(json).unwrap_or_else(|_| {
-                    r#"{"error": "Failed to serialize JSON"}"#.to_string()
-                });
-                hyper::Response::builder()
-                    .status(200)
-                    .header("Content-Type", "application/json")
-                    .body(body)
-                    .unwrap()
-            }
-            ZapResponse::JsonWithStatus(json, status) => {
-                let body = serde_json::to_string(json).unwrap_or_else(|_| {
-                    r#"{"error": "Failed to serialize JSON"}"#.to_string()
-                });
-                hyper::Response::builder()
-                    .status(*status)
-                    .header("Content-Type", "application/json")
-                    .body(body)
-                    .unwrap()
-            }
-            ZapResponse::Bytes(bytes) => hyper::Response::builder()
-                .status(200)
-                .header("Content-Type", "application/octet-stream")
-                .body(String::from_utf8_lossy(bytes).to_string())
-                .unwrap(),
-            ZapResponse::Custom(response) => {
-                let status = response.status.as_u16();
-                let mut builder = hyper::Response::builder().status(status);
-                
-                for (key, value) in &response.headers {
-                    builder = builder.header(key, value);
-                }
-                
-                let body = match &response.body {
-                    ResponseBody::Empty => String::new(),
-                    ResponseBody::Text(text) => text.clone(),
-                    ResponseBody::Bytes(bytes) => {
-                        String::from_utf8_lossy(bytes).to_string()
-                    }
-                };
-                
-                builder.body(body).unwrap()
-            }
-            ZapResponse::Redirect(location) => hyper::Response::builder()
-                .status(302)
-                .header("Location", location)
-                .body(String::new())
-                .unwrap(),
-            ZapResponse::Status(status) => hyper::Response::builder()
-                .status(status.as_u16())
-                .body(String::new())
-                .unwrap(),
-            ZapResponse::File(_path) => {
-                // File serving would be implemented here
-                // For now, return not implemented
-                hyper::Response::builder()
-                    .status(501)
-                    .body("File serving not yet implemented".to_string())
-                    .unwrap()
-            }
-            ZapResponse::Stream(stream_response) => {
-                let mut builder = hyper::Response::builder()
-                    .status(stream_response.status);
-
-                // Add all headers from the streaming response
-                for (key, value) in &stream_response.headers {
-                    builder = builder.header(key, value);
-                }
-
-                // Convert chunks to body
-                let body = stream_response.body_string();
-                builder.body(body).unwrap()
-            }
-        }
-    }
-} 

package/src/rpc.js

@@ -1,14 +0,0 @@
-/**
- * @zap-js/server/rpc
- * 
- * RPC client for server communication
- */
-
-import { rpcCall } from '../../client/internal/runtime/src/rpc-client.js';
-
-// RPC object with call method
-const rpc = {
-  call: rpcCall,
-};
-
-export default rpc;