@zap-js/server 0.0.2 → 0.0.4

package/index.js

@@ -1,21 +1,25 @@
 /**
  * @zap-js/server
- * 
+ *
  * ZapJS server communication utilities
+ * Re-exports from @zap-js/client
  */
 
-// RPC client
-import rpc from './src/rpc.js';
+// Namespace exports (Clean API)
 
-// IPC client
-import ipc from './src/ipc.js';
-
-// Types
-import * as types from './src/types.js';
+/**
+ * RPC namespace - Remote Procedure Call utilities
+ * Usage: import { rpc } from '@zap-js/server'
+ * Then: rpc.call('functionName', args)
+ */
+import { rpcCall } from '@zap-js/client';
+export const rpc = {
+  call: rpcCall,
+};
 
-// Export everything
-export {
-  rpc,
-  ipc,
-  types
-};
+/**
+ * Types namespace - re-export from client
+ * Usage: import { types } from '@zap-js/server'
+ */
+import { types as clientTypes } from '@zap-js/client';
+export const types = clientTypes;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zap-js/server",
-  "version": "0.0.2",
+  "version": "0.0.4",
   "description": "High-performance fullstack React framework - Server package with Rust-powered backend",
   "homepage": "https://github.com/saint0x/zapjs",
   "repository": {
@@ -16,15 +16,10 @@
     ".": "./index.js"
   },
   "files": [
-    "index.js",
-    "src",
-    "internal",
-    "!internal/*/src/**/*.rs",
-    "!internal/*/Cargo.toml"
+    "index.js"
   ],
-  "scripts": {
-    "build": "echo 'No build needed for server package'",
-    "clean": "rm -rf dist"
+  "dependencies": {
+    "@zap-js/client": "^0.0.4"
   },
   "keywords": [
     "zap",

package/src/bin/zap.rs

@@ -1,154 +0,0 @@
-//! 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

@@ -1,253 +0,0 @@
-//! 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)
-    }
-}