@zap-js/server 0.0.1

package/README.md

@@ -0,0 +1,51 @@
+# @zap-js/server
+
+Server-side package for the ZapJS fullstack React framework with Rust-powered backend.
+
+## Installation
+
+```bash
+npm install @zap-js/server
+```
+
+## Usage
+
+```javascript
+import { rpc, ipc } from '@zap-js/server'
+
+// Call Rust backend functions
+const result = await rpc.call('getUser', { id: 123 })
+
+// Direct IPC communication
+const client = new ipc.Client('/tmp/zap.sock')
+```
+
+## Features
+
+- **Rust-powered backend** with 9ns route matching
+- **Automatic TypeScript bindings** for Rust functions
+- **Zero-overhead RPC** communication
+- **Type-safe** end-to-end
+
+## API Routes
+
+Use server exports in your API route handlers:
+
+```javascript
+// routes/api/users.ts
+import { rpc } from '@zap-js/server'
+
+export const GET = async (req) => {
+  return await rpc.call('list_users', {
+    limit: req.query.limit || 10
+  })
+}
+```
+
+## Documentation
+
+Full documentation available at [https://github.com/saint0x/zapjs](https://github.com/saint0x/zapjs)
+
+## License
+
+MIT

package/index.js

@@ -0,0 +1,21 @@
+/**
+ * @zap-js/server
+ * 
+ * ZapJS server communication utilities
+ */
+
+// RPC client
+import rpc from './src/rpc.js';
+
+// IPC client
+import ipc from './src/ipc.js';
+
+// Types
+import * as types from './src/types.js';
+
+// Export everything
+export {
+  rpc,
+  ipc,
+  types
+};

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@zap-js/server",
+  "version": "0.0.1",
+  "description": "High-performance fullstack React framework - Server package with Rust-powered backend",
+  "homepage": "https://github.com/saint0x/zapjs",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/saint0x/zapjs.git"
+  },
+  "bugs": {
+    "url": "https://github.com/saint0x/zapjs/issues"
+  },
+  "type": "module",
+  "main": "./index.js",
+  "exports": {
+    ".": "./index.js"
+  },
+  "files": [
+    "index.js",
+    "src",
+    "internal",
+    "!internal/*/src/**/*.rs",
+    "!internal/*/Cargo.toml"
+  ],
+  "scripts": {
+    "build": "echo 'No build needed for server package'",
+    "clean": "rm -rf dist"
+  },
+  "keywords": [
+    "zap",
+    "zapjs",
+    "zap-js",
+    "server",
+    "rust",
+    "rpc",
+    "ipc",
+    "typescript",
+    "fullstack",
+    "framework",
+    "http",
+    "websocket",
+    "performance",
+    "backend"
+  ],
+  "author": "saint0x",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/src/bin/zap.rs

@@ -0,0 +1,154 @@
+//! Zap HTTP Server - High-Performance Rust-Based Server
+//!
+//! Ultra-fast HTTP server with SIMD optimizations and Unix socket IPC
+//! for TypeScript handler invocation.
+
+use clap::Parser;
+use std::path::PathBuf;
+use tokio::signal;
+use tracing::{error, info};
+use tracing_subscriber::EnvFilter;
+
+use zap_server::config::ZapConfig;
+use zap_server::error::ZapResult;
+use zap_server::Zap;
+
+#[derive(Parser, Debug)]
+#[command(name = "Zap")]
+#[command(version = "1.0.0")]
+#[command(about = "Ultra-fast HTTP server for Node.js/Bun", long_about = None)]
+struct Args {
+    /// Path to JSON configuration file
+    #[arg(short, long)]
+    config: PathBuf,
+
+    /// Override HTTP server port
+    #[arg(short, long)]
+    port: Option<u16>,
+
+    /// Override HTTP server hostname
+    #[arg(long)]
+    hostname: Option<String>,
+
+    /// Unix socket path for IPC with TypeScript wrapper
+    #[arg(short, long)]
+    socket: Option<String>,
+
+    /// Log level (trace, debug, info, warn, error)
+    #[arg(long, default_value = "info")]
+    log_level: String,
+}
+
+#[tokio::main]
+async fn main() -> ZapResult<()> {
+    let args = Args::parse();
+
+    // Initialize logging
+    init_logging(&args.log_level)?;
+
+    info!("🚀 Starting Zap HTTP server v1.0.0");
+
+    // Load configuration from JSON file
+    let mut config = ZapConfig::from_file(args.config.to_str().unwrap())?;
+
+    info!(
+        "📋 Configuration loaded from {}",
+        args.config.display()
+    );
+
+    // Apply CLI argument overrides
+    if let Some(port) = args.port {
+        info!("⚙️  Overriding port: {}", port);
+        config.port = port;
+    }
+    if let Some(hostname) = args.hostname {
+        info!("⚙️  Overriding hostname: {}", hostname);
+        config.hostname = hostname;
+    }
+    if let Some(socket) = args.socket {
+        info!("⚙️  Overriding IPC socket: {}", socket);
+        config.ipc_socket_path = socket;
+    }
+
+    // Validate configuration
+    config.validate().await?;
+
+    info!(
+        "📡 Server will listen on http://{}:{}",
+        config.hostname, config.port
+    );
+    info!("🔌 IPC socket: {}", config.ipc_socket_path);
+    info!("📊 Routes: {}", config.routes.len());
+    info!("📁 Static files: {}", config.static_files.len());
+
+    // Create and start the server
+    let app = Zap::from_config(config).await?;
+
+    info!("✅ Zap server initialized successfully");
+
+    // Run the server (blocks until signal)
+    // Note: listen() takes ownership and runs indefinitely
+    tokio::select! {
+        result = app.listen() => {
+            if let Err(e) = result {
+                error!("Server error: {}", e);
+                return Err(e);
+            }
+        }
+        _ = setup_signal_handlers() => {
+            info!("📛 Received shutdown signal");
+        }
+    }
+
+    info!("👋 Zap server shut down successfully");
+    Ok(())
+}
+
+/// Initialize structured logging with configurable level
+fn init_logging(level: &str) -> ZapResult<()> {
+    let env_filter = level.parse::<EnvFilter>().map_err(|e| {
+        zap_server::error::ZapError::config(format!(
+            "Invalid log level '{}': {}",
+            level, e
+        ))
+    })?;
+
+    tracing_subscriber::fmt()
+        .with_env_filter(env_filter)
+        .with_target(true)
+        .with_file(true)
+        .with_line_number(true)
+        .with_ansi(true)
+        .init();
+
+    Ok(())
+}
+
+/// Setup Unix signal handlers for graceful shutdown
+async fn setup_signal_handlers() {
+    #[cfg(unix)]
+    {
+        let mut sigterm = signal::unix::signal(signal::unix::SignalKind::terminate())
+            .expect("Failed to setup SIGTERM handler");
+        let mut sigint = signal::unix::signal(signal::unix::SignalKind::interrupt())
+            .expect("Failed to setup SIGINT handler");
+
+        tokio::select! {
+            _ = sigterm.recv() => {
+                info!("Received SIGTERM signal");
+            }
+            _ = sigint.recv() => {
+                info!("Received SIGINT signal");
+            }
+            _ = signal::ctrl_c() => {
+                info!("Received Ctrl+C");
+            }
+        }
+    }
+
+    #[cfg(not(unix))]
+    {
+        let _ = signal::ctrl_c().await;
+        info!("Received Ctrl+C");
+    }
+}

package/src/config.rs

@@ -0,0 +1,253 @@
+//! Server configuration
+//!
+//! Comprehensive configuration system supporting:
+//! - JSON config files
+//! - Environment variables
+//! - CLI argument overrides
+
+use serde::{Deserialize, Serialize};
+use std::time::Duration;
+use crate::error::{ZapError, ZapResult};
+
+/// Complete Zap server configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ZapConfig {
+    /// HTTP server port
+    pub port: u16,
+
+    /// HTTP server hostname
+    pub hostname: String,
+
+    /// Unix domain socket path for IPC with TypeScript
+    pub ipc_socket_path: String,
+
+    /// Maximum request body size in bytes (default: 16MB)
+    #[serde(default = "default_max_body_size")]
+    pub max_request_body_size: usize,
+
+    /// Request timeout in seconds
+    #[serde(default = "default_request_timeout")]
+    pub request_timeout_secs: u64,
+
+    /// Keep-alive timeout in seconds
+    #[serde(default = "default_keepalive_timeout")]
+    pub keepalive_timeout_secs: u64,
+
+    /// Route configurations
+    #[serde(default)]
+    pub routes: Vec<RouteConfig>,
+
+    /// Static file configurations
+    #[serde(default)]
+    pub static_files: Vec<StaticFileConfig>,
+
+    /// Middleware settings
+    #[serde(default)]
+    pub middleware: MiddlewareConfig,
+
+    /// Health check endpoint path
+    #[serde(default = "default_health_path")]
+    pub health_check_path: String,
+
+    /// Metrics endpoint path
+    #[serde(default)]
+    pub metrics_path: Option<String>,
+}
+
+/// Route configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct RouteConfig {
+    /// HTTP method: GET, POST, PUT, DELETE, PATCH, HEAD, OPTIONS
+    pub method: String,
+
+    /// URL path pattern: /api/users/:id
+    pub path: String,
+
+    /// Handler ID: handler_0, handler_1, etc.
+    pub handler_id: String,
+
+    /// Is this a TypeScript handler (needs IPC), or Rust native?
+    #[serde(default = "default_is_typescript")]
+    pub is_typescript: bool,
+}
+
+/// Static file serving configuration
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct StaticFileConfig {
+    /// URL prefix: /static
+    pub prefix: String,
+
+    /// Directory path: ./public
+    pub directory: String,
+
+    /// Additional options
+    #[serde(default)]
+    pub options: StaticFileOptions,
+}
+
+/// Static file serving options
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct StaticFileOptions {
+    /// Cache control header value
+    #[serde(default)]
+    pub cache_control: Option<String>,
+
+    /// Enable gzip compression
+    #[serde(default)]
+    pub enable_gzip: bool,
+}
+
+/// Middleware configuration
+#[derive(Debug, Clone, Serialize, Deserialize, Default)]
+pub struct MiddlewareConfig {
+    /// Enable CORS middleware
+    #[serde(default)]
+    pub enable_cors: bool,
+
+    /// Enable request logging middleware
+    #[serde(default)]
+    pub enable_logging: bool,
+
+    /// Enable response compression
+    #[serde(default)]
+    pub enable_compression: bool,
+}
+
+impl Default for ZapConfig {
+    fn default() -> Self {
+        Self {
+            port: 3000,
+            hostname: "127.0.0.1".to_string(),
+            ipc_socket_path: "/tmp/zap.sock".to_string(),
+            max_request_body_size: 16 * 1024 * 1024, // 16MB
+            request_timeout_secs: 30,
+            keepalive_timeout_secs: 75,
+            routes: Vec::new(),
+            static_files: Vec::new(),
+            middleware: MiddlewareConfig::default(),
+            health_check_path: "/health".to_string(),
+            metrics_path: None,
+        }
+    }
+}
+
+impl ZapConfig {
+    /// Create a new config with defaults
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    /// Load configuration from a JSON file
+    pub fn from_file(path: &str) -> ZapResult<Self> {
+        let content = std::fs::read_to_string(path)
+            .map_err(|e| ZapError::config(format!("Failed to read config file: {}", e)))?;
+
+        let config = serde_json::from_str(&content)
+            .map_err(|e| ZapError::config(format!("Failed to parse config JSON: {}", e)))?;
+
+        Ok(config)
+    }
+
+    /// Validate configuration
+    pub async fn validate(&self) -> ZapResult<()> {
+        if self.port == 0 {
+            return Err(ZapError::config("Port must be > 0"));
+        }
+        if self.hostname.is_empty() {
+            return Err(ZapError::config("Hostname cannot be empty"));
+        }
+        if self.ipc_socket_path.is_empty() {
+            return Err(ZapError::config("IPC socket path cannot be empty"));
+        }
+        if self.request_timeout_secs == 0 {
+            return Err(ZapError::config("Request timeout must be > 0"));
+        }
+        Ok(())
+    }
+
+    /// Get socket address as string
+    pub fn socket_addr(&self) -> String {
+        format!("{}:{}", self.hostname, self.port)
+    }
+
+    /// Get request timeout as Duration
+    pub fn request_timeout(&self) -> Duration {
+        Duration::from_secs(self.request_timeout_secs)
+    }
+
+    /// Get keep-alive timeout as Duration
+    pub fn keepalive_timeout(&self) -> Duration {
+        Duration::from_secs(self.keepalive_timeout_secs)
+    }
+}
+
+// Default function values for serde
+fn default_max_body_size() -> usize { 16 * 1024 * 1024 }
+fn default_request_timeout() -> u64 { 30 }
+fn default_keepalive_timeout() -> u64 { 75 }
+fn default_health_path() -> String { "/health".to_string() }
+fn default_is_typescript() -> bool { true }
+
+/// Legacy ServerConfig for compatibility
+#[derive(Debug, Clone)]
+pub struct ServerConfig {
+    pub port: u16,
+    pub hostname: String,
+    pub keep_alive_timeout: Duration,
+    pub max_request_body_size: usize,
+    pub max_headers: usize,
+    pub request_timeout: Duration,
+}
+
+impl Default for ServerConfig {
+    fn default() -> Self {
+        Self {
+            port: 3000,
+            hostname: "127.0.0.1".to_string(),
+            keep_alive_timeout: Duration::from_secs(75),
+            max_request_body_size: 16 * 1024 * 1024,
+            max_headers: 100,
+            request_timeout: Duration::from_secs(30),
+        }
+    }
+}
+
+impl ServerConfig {
+    pub fn new() -> Self {
+        Self::default()
+    }
+
+    pub fn port(mut self, port: u16) -> Self {
+        self.port = port;
+        self
+    }
+
+    pub fn hostname<S: Into<String>>(mut self, hostname: S) -> Self {
+        self.hostname = hostname.into();
+        self
+    }
+
+    pub fn keep_alive_timeout(mut self, timeout: Duration) -> Self {
+        self.keep_alive_timeout = timeout;
+        self
+    }
+
+    pub fn max_request_body_size(mut self, size: usize) -> Self {
+        self.max_request_body_size = size;
+        self
+    }
+
+    pub fn max_headers(mut self, count: usize) -> Self {
+        self.max_headers = count;
+        self
+    }
+
+    pub fn request_timeout(mut self, timeout: Duration) -> Self {
+        self.request_timeout = timeout;
+        self
+    }
+
+    pub fn socket_addr(&self) -> String {
+        format!("{}:{}", self.hostname, self.port)
+    }
+}