bxo 0.0.10-dev.2 → 0.0.10-dev.4

package/example/deployment-examples.ts

@@ -0,0 +1,136 @@
+import BXO from "../src";
+
+// Example configurations for different deployment scenarios
+
+// 1. Development - Local only
+export const developmentConfig = new BXO({
+    serve: {
+        hostname: "127.0.0.1",  // Only localhost
+        port: 3000,
+        development: true
+    }
+});
+
+// 2. Local Network - Accessible from other devices on same network
+export const localNetworkConfig = new BXO({
+    serve: {
+        hostname: "0.0.0.0",    // All interfaces
+        port: 3000,
+        development: true
+    }
+});
+
+// 3. Production - External access with security
+export const productionConfig = new BXO({
+    serve: {
+        hostname: "0.0.0.0",    // All interfaces
+        port: 8080,
+        development: false
+    }
+});
+
+// 4. Docker Container - Internal network
+export const dockerConfig = new BXO({
+    serve: {
+        hostname: "0.0.0.0",    // All interfaces (required for Docker)
+        port: 3000,
+        development: false
+    }
+});
+
+// 5. Cloud Deployment (AWS, GCP, Azure)
+export const cloudConfig = new BXO({
+    serve: {
+        hostname: "0.0.0.0",    // All interfaces
+        port: process.env.PORT || 8080,  // Use environment port
+        development: false
+    }
+});
+
+// 6. Specific IP binding
+export const specificIPConfig = new BXO({
+    serve: {
+        hostname: "192.168.1.100",  // Specific IP
+        port: 3000
+    }
+});
+
+// 7. Domain binding (if you have a specific domain)
+export const domainConfig = new BXO({
+    serve: {
+        hostname: "api.yourdomain.com",  // Specific domain
+        port: 80
+    }
+});
+
+// Example usage function
+async function runExample() {
+    console.log("🚀 BXO Deployment Configuration Examples\n");
+    
+    // Choose which configuration to use
+    const app = localNetworkConfig; // Change this to test different configs
+    
+    // Add some routes
+    app.get("/", (ctx) => {
+        return ctx.json({
+            message: "BXO Server Running",
+            hostname: app.server?.hostname || "default",
+            port: app.server?.port,
+            environment: process.env.NODE_ENV || "development",
+            accessible: app.server?.hostname === "0.0.0.0" ? "External networks" : "Local only"
+        });
+    });
+    
+    app.get("/health", (ctx) => {
+        return ctx.json({
+            status: "healthy",
+            timestamp: new Date().toISOString(),
+            hostname: app.server?.hostname,
+            port: app.server?.port
+        });
+    });
+    
+    // WebSocket example with hostname info
+    app.ws("/ws", {
+        open(ws) {
+            const data = ws.data;
+            console.log(`🔌 WebSocket connected from ${data.ip} to hostname: ${app.server?.hostname}`);
+            ws.send(`Connected to server on ${app.server?.hostname}:${app.server?.port}`);
+        },
+        
+        message(ws, message) {
+            const data = ws.data;
+            console.log(`💬 Message from ${data.ip}: ${message}`);
+            ws.send(`Echo from ${app.server?.hostname}: ${message}`);
+        }
+    });
+    
+    app.start();
+    
+    console.log(`✅ Server started successfully!`);
+    console.log(`📍 Hostname: ${app.server?.hostname}`);
+    console.log(`🔌 Port: ${app.server?.port}`);
+    console.log(`🌐 Access URLs:`);
+    
+    if (app.server?.hostname === "0.0.0.0") {
+        console.log(`   • http://localhost:${app.server.port}`);
+        console.log(`   • http://127.0.0.1:${app.server.port}`);
+        console.log(`   • http://your-server-ip:${app.server.port}`);
+        console.log(`   • http://your-domain.com:${app.server.port}`);
+    } else if (app.server?.hostname === "127.0.0.1") {
+        console.log(`   • http://localhost:${app.server.port}`);
+        console.log(`   • http://127.0.0.1:${app.server.port}`);
+    } else {
+        console.log(`   • http://${app.server?.hostname}:${app.server?.port}`);
+    }
+    
+    console.log(`\n📋 Configuration Guide:`);
+    console.log(`   • Development: hostname: "127.0.0.1" (localhost only)`);
+    console.log(`   • Local Network: hostname: "0.0.0.0" (all interfaces)`);
+    console.log(`   • Production: hostname: "0.0.0.0" + reverse proxy`);
+    console.log(`   • Docker: hostname: "0.0.0.0" (required for container networking)`);
+    console.log(`   • Cloud: hostname: "0.0.0.0" + environment port`);
+}
+
+// Run the example
+runExample().catch(console.error);

package/example/hostname-example.ts

@@ -0,0 +1,127 @@
+import BXO from "../src";
+
+async function main() {
+    console.log("🌐 BXO Hostname Configuration Examples\n");
+
+    // Example 1: Serve on all interfaces (0.0.0.0) - accessible from external networks
+    console.log("1. Serving on all interfaces (0.0.0.0) - accessible from external networks");
+    const app1 = new BXO({
+        serve: {
+            hostname: "0.0.0.0",  // Listen on all network interfaces
+            port: 3000
+        }
+    });
+
+    app1.get("/", (ctx) => {
+        return ctx.json({
+            message: "Hello from BXO!",
+            hostname: "0.0.0.0",
+            accessible: "From any network interface",
+            examples: [
+                "http://localhost:3000",
+                "http://127.0.0.1:3000", 
+                "http://your-server-ip:3000",
+                "http://your-domain.com:3000"
+            ]
+        });
+    });
+
+    // Example 2: Serve on specific hostname/IP
+    console.log("2. Serving on specific hostname/IP");
+    const app2 = new BXO({
+        serve: {
+            hostname: "127.0.0.1",  // Only localhost
+            port: 3001
+        }
+    });
+
+    app2.get("/", (ctx) => {
+        return ctx.json({
+            message: "Hello from BXO!",
+            hostname: "127.0.0.1",
+            accessible: "Only from localhost",
+            examples: [
+                "http://localhost:3001",
+                "http://127.0.0.1:3001"
+            ]
+        });
+    });
+
+    // Example 3: Production configuration with external access
+    console.log("3. Production configuration with external access");
+    const app3 = new BXO({
+        serve: {
+            hostname: "0.0.0.0",  // Listen on all interfaces
+            port: 8080,
+            // Additional production options
+            development: false,
+            // You can add more Bun.serve options here
+        }
+    });
+
+    app3.get("/", (ctx) => {
+        return ctx.json({
+            message: "Production BXO Server",
+            hostname: "0.0.0.0",
+            port: 8080,
+            accessible: "From external networks",
+            deployment: "Production ready"
+        });
+    });
+
+    // Example 4: Custom hostname for specific deployment
+    console.log("4. Custom hostname for specific deployment");
+    const app4 = new BXO({
+        serve: {
+            hostname: "192.168.1.100",  // Specific IP address
+            port: 4000
+        }
+    });
+
+    app4.get("/", (ctx) => {
+        return ctx.json({
+            message: "BXO on specific IP",
+            hostname: "192.168.1.100",
+            accessible: "From network 192.168.1.x",
+            examples: [
+                "http://192.168.1.100:4000"
+            ]
+        });
+    });
+
+    // Start the server you want to test
+    const selectedApp = app1; // Change this to app1, app2, app3, or app4
+    
+    selectedApp.start();
+    
+    console.log(`🚀 Server started!`);
+    console.log(`📍 Hostname: ${selectedApp.server?.hostname || 'default'}`);
+    console.log(`🔌 Port: ${selectedApp.server?.port}`);
+    console.log(`🌐 Accessible at:`);
+    
+    if (selectedApp === app1) {
+        console.log(`   • http://localhost:3000`);
+        console.log(`   • http://127.0.0.1:3000`);
+        console.log(`   • http://your-server-ip:3000`);
+        console.log(`   • http://your-domain.com:3000`);
+    } else if (selectedApp === app2) {
+        console.log(`   • http://localhost:3001`);
+        console.log(`   • http://127.0.0.1:3001`);
+    } else if (selectedApp === app3) {
+        console.log(`   • http://localhost:8080`);
+        console.log(`   • http://your-server-ip:8080`);
+        console.log(`   • http://your-domain.com:8080`);
+    } else if (selectedApp === app4) {
+        console.log(`   • http://192.168.1.100:4000`);
+    }
+    
+    console.log(`\n📝 Configuration Options:`);
+    console.log(`   • hostname: "0.0.0.0" - Listen on all interfaces (external access)`);
+    console.log(`   • hostname: "127.0.0.1" - Only localhost access`);
+    console.log(`   • hostname: "192.168.1.100" - Specific IP address`);
+    console.log(`   • hostname: "your-domain.com" - Specific domain`);
+    console.log(`   • port: 3000 - Custom port number`);
+    console.log(`   • development: false - Production mode`);
+}
+
+main().catch(console.error);

package/example/ip-detection-example.ts

@@ -0,0 +1,194 @@
+import BXO from "../src";
+
+async function main() {
+    const app = new BXO({ serve: { port: 3000, hostname: '0.0.0.0' } });
+
+    // Enhanced IP detection function
+    function getClientIP(req: Request): string {
+        // Check proxy headers first
+        const forwardedFor = req.headers.get("x-forwarded-for");
+        const realIP = req.headers.get("x-real-ip");
+        const clientIP = req.headers.get("x-client-ip");
+        const cfConnectingIP = req.headers.get("cf-connecting-ip"); // Cloudflare
+
+        if (forwardedFor) {
+            // X-Forwarded-For can contain multiple IPs: "client, proxy1, proxy2"
+            // The first IP is usually the original client
+            return forwardedFor.split(',')[0].trim();
+        }
+
+        if (realIP) return realIP;
+        if (clientIP) return clientIP;
+        if (cfConnectingIP) return cfConnectingIP;
+
+        // If no proxy headers, try to get from connection
+        // Note: This is a workaround since Bun doesn't expose connection IP directly
+        // In production, you should always use a reverse proxy that sets proper headers
+
+        // For localhost development, return localhost
+        const host = req.headers.get("host");
+        if (host?.includes("localhost") || host?.includes("127.0.0.1")) {
+            return "127.0.0.1";
+        }
+
+        return "unknown";
+    }
+
+    // HTTP route with enhanced IP detection
+    app.get("/api/ip", (ctx) => {
+        const ip = getClientIP(ctx.request);
+
+        return ctx.json({
+            ip: ip,
+            headers: {
+                "x-forwarded-for": ctx.headers["x-forwarded-for"],
+                "x-real-ip": ctx.headers["x-real-ip"],
+                "x-client-ip": ctx.headers["x-client-ip"],
+                "cf-connecting-ip": ctx.headers["cf-connecting-ip"],
+                "host": ctx.headers["host"]
+            },
+            allHeaders: ctx.headers,
+            message: ip === "unknown" ?
+                "IP detection failed. In production, use a reverse proxy (nginx, Cloudflare, etc.) that sets X-Forwarded-For headers." :
+                "IP detected successfully!"
+        });
+    });
+
+    // WebSocket route with enhanced IP detection
+    app.ws("/ws", {
+        open(ws) {
+            // For WebSocket, we need to get IP from the original request
+            // This is a workaround since BXO's WebSocket data might show "unknown"
+            const ip = ws.data.ip !== "unknown" ? ws.data.ip : "127.0.0.1";
+
+            console.log(`WebSocket client connected from IP: ${ip}`);
+            ws.send(`Hello! Your IP is: ${ip}`);
+        },
+        message(ws, message) {
+            const ip = ws.data.ip !== "unknown" ? ws.data.ip : "127.0.0.1";
+            console.log(`Message from ${ip}: ${message}`);
+            ws.send(`Echo: ${message} (from IP: ${ip})`);
+        }
+    });
+
+    // Debug route to see all headers
+    app.get("/debug", (ctx) => {
+        return ctx.json({
+            message: "Debug information",
+            headers: ctx.headers,
+            cookies: ctx.cookies,
+            userAgent: ctx.headers["user-agent"]
+        });
+    });
+
+    // Home page with test interface
+    app.get("/", (ctx) => {
+        return ctx.html(`
+<!DOCTYPE html>
+<html>
+<head>
+    <title>BXO IP Detection Test</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        button { padding: 10px 20px; margin: 10px; background: #007bff; color: white; border: none; border-radius: 5px; cursor: pointer; }
+        button:hover { background: #0056b3; }
+        .result { background: #f8f9fa; padding: 20px; margin: 20px 0; border-radius: 5px; }
+        pre { background: #e9ecef; padding: 10px; border-radius: 3px; overflow-x: auto; }
+    </style>
+</head>
+<body>
+    <h1>BXO IP Detection Test</h1>
+    
+    <div>
+        <button onclick="checkIP()">Check My IP</button>
+        <button onclick="checkDebug()">Debug Headers</button>
+        <button onclick="connectWebSocket()">Connect WebSocket</button>
+    </div>
+    
+    <div id="result" class="result" style="display: none;">
+        <h3>Result:</h3>
+        <pre id="resultContent"></pre>
+    </div>
+    
+    <div id="wsMessages" class="result" style="display: none;">
+        <h3>WebSocket Messages:</h3>
+        <div id="wsContent"></div>
+    </div>
+    
+    <script>
+        let ws = null;
+        
+        async function checkIP() {
+            try {
+                const res = await fetch('/api/ip');
+                const data = await res.json();
+                showResult(data);
+            } catch (error) {
+                showResult({ error: error.message });
+            }
+        }
+        
+        async function checkDebug() {
+            try {
+                const res = await fetch('/debug');
+                const data = await res.json();
+                showResult(data);
+            } catch (error) {
+                showResult({ error: error.message });
+            }
+        }
+        
+        function connectWebSocket() {
+            if (ws) {
+                ws.close();
+            }
+            
+            ws = new WebSocket('ws://localhost:3000/ws');
+            
+            ws.onopen = function() {
+                addWSMessage('Connected to WebSocket');
+            };
+            
+            ws.onmessage = function(event) {
+                addWSMessage('Received: ' + event.data);
+            };
+            
+            ws.onclose = function() {
+                addWSMessage('Disconnected from WebSocket');
+            };
+            
+            ws.onerror = function(error) {
+                addWSMessage('Error: ' + error);
+            };
+        }
+        
+        function showResult(data) {
+            document.getElementById('result').style.display = 'block';
+            document.getElementById('resultContent').textContent = JSON.stringify(data, null, 2);
+        }
+        
+        function addWSMessage(message) {
+            document.getElementById('wsMessages').style.display = 'block';
+            const div = document.createElement('div');
+            div.textContent = new Date().toLocaleTimeString() + ': ' + message;
+            document.getElementById('wsContent').appendChild(div);
+        }
+    </script>
+</body>
+</html>
+        `);
+    });
+
+    console.log("🚀 BXO IP Detection Example");
+    console.log("📡 Server running on http://localhost:3000");
+    console.log("🔍 Visit http://localhost:3000 to test IP detection");
+    console.log("\n💡 Tips for getting real IP addresses:");
+    console.log("1. Use a reverse proxy (nginx, Apache) that sets X-Forwarded-For headers");
+    console.log("2. Deploy behind Cloudflare (sets CF-Connecting-IP header)");
+    console.log("3. Use AWS ALB/ELB (sets X-Forwarded-For header)");
+    console.log("4. For local development, IP will show as 127.0.0.1 or unknown");
+
+    app.start();
+}
+
+main().catch(console.error);

package/example/nginx.conf

@@ -0,0 +1,48 @@
+# Nginx configuration for BXO with proper IP forwarding
+# This ensures X-Forwarded-For headers are set correctly
+
+server {
+    listen 80;
+    server_name your-domain.com;
+    
+    # Forward all requests to BXO server
+    location / {
+        proxy_pass http://127.0.0.1:3000;
+        
+        # Set headers for IP detection
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        
+        # WebSocket support
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}
+
+# HTTPS version (recommended for production)
+server {
+    listen 443 ssl;
+    server_name your-domain.com;
+    
+    # SSL configuration
+    ssl_certificate /path/to/your/certificate.crt;
+    ssl_certificate_key /path/to/your/private.key;
+    
+    location / {
+        proxy_pass http://127.0.0.1:3000;
+        
+        # Set headers for IP detection
+        proxy_set_header Host $host;
+        proxy_set_header X-Real-IP $remote_addr;
+        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
+        proxy_set_header X-Forwarded-Proto $scheme;
+        
+        # WebSocket support
+        proxy_http_version 1.1;
+        proxy_set_header Upgrade $http_upgrade;
+        proxy_set_header Connection "upgrade";
+    }
+}

package/example/websocket-example.ts

@@ -1,7 +1,13 @@
 import BXO from "../src";
 
 async function main() {
-    const app = new BXO({ serve: { port: 3000 } });
+    // Configure hostname for external access
+    const app = new BXO({ 
+        serve: { 
+            hostname: "0.0.0.0",  // Listen on all interfaces for external access
+            port: 3000 
+        } 
+    });
 
     // HTTP routes
     app.get("/", (ctx) => {
@@ -252,9 +258,19 @@ async function main() {
     });
 
     app.start();
-    console.log(`🚀 Server is running on http://localhost:${app.server?.port}`);
-    console.log(`🔌 WebSocket available at ws://localhost:${app.server?.port}/ws`);
-    console.log(`💬 Chat WebSocket available at ws://localhost:${app.server?.port}/chat/:room`);
+    console.log(`🚀 Server is running:`);
+    console.log(`📍 Hostname: ${app.server?.hostname || 'default'}`);
+    console.log(`🔌 Port: ${app.server?.port}`);
+    console.log(`🌐 HTTP: http://localhost:${app.server?.port}`);
+    console.log(`🔌 WebSocket: ws://localhost:${app.server?.port}/ws`);
+    console.log(`💬 Chat WebSocket: ws://localhost:${app.server?.port}/chat/:room`);
+    
+    if (app.server?.hostname === "0.0.0.0") {
+        console.log(`\n🌍 External Access Available:`);
+        console.log(`   • http://your-server-ip:${app.server.port}`);
+        console.log(`   • http://your-domain.com:${app.server.port}`);
+        console.log(`   • ws://your-server-ip:${app.server.port}/ws`);
+    }
     console.log(`\n📝 Features demonstrated:`);
     console.log(`   • ws.data.id - Short, unique client identifier`);
     console.log(`   • ws.data.connectionId - Detailed connection ID`);

package/package.json

@@ -5,7 +5,7 @@
     ".": "./src/index.ts",
     "./plugins": "./plugins/index.ts"
   },
-  "version": "0.0.10-dev.2",
+  "version": "0.0.10-dev.4",
   "type": "module",
   "devDependencies": {
     "@types/bun": "latest"

package/src/index.ts

@@ -82,6 +82,7 @@ export type Context<P extends string = string, S extends RouteSchema | undefined
     };
     json: <T>(data: T, status?: number) => Response;
     text: (data: string, status?: number) => Response;
+    html: (data: string, status?: number) => Response;
     status: <T extends number>(status: T, data: InferResponse<S, T>) => Response;
     redirect: (url: string, status?: 301 | 302 | 303 | 307 | 308) => Response;
 };
@@ -195,11 +196,14 @@ function parseQuery<T extends z.ZodTypeAny>(searchParams: URLSearchParams, schem
 function parseQuery(searchParams: URLSearchParams, schema?: z.ZodTypeAny): any {
     const out: QueryObject = {};
     for (const [k, v] of searchParams.entries()) {
-        if (k in out) {
-            const existing = out[k];
-            if (Array.isArray(existing)) out[k] = [...existing, v];
-            else out[k] = [existing as string, v];
-        } else out[k] = v;
+        // Handle array notation like fields[] -> fields
+        const key = k.endsWith('[]') ? k.slice(0, -2) : k;
+        
+        if (key in out) {
+            const existing = out[key];
+            if (Array.isArray(existing)) out[key] = [...existing, v];
+            else out[key] = [existing as string, v];
+        } else out[key] = v;
     }
     if (schema) {
         return (schema as any).parse ? (schema as any).parse(out) : out;
@@ -808,6 +812,19 @@ export default class BXO {
                     headers: { "Content-Type": "text/plain" }
                 });
             },
+            html: (data, status = 200) => {
+                if (route.schema?.response?.[status]) {
+                    const sch = route.schema.response[status]!;
+                    const res = (sch as any).safeParse ? (sch as any).safeParse(data) : { success: true };
+                    if (!res.success) {
+                        return new Response(JSON.stringify({ error: "Invalid response", issues: res.error?.issues ?? [] }), { status: 500, headers: { "Content-Type": "application/json" } });
+                    }
+                }
+                return new Response(String(data), {
+                    status,
+                    headers: { "Content-Type": "text/html; charset=utf-8" }
+                });
+            },
             status: (status, data) => {
                 // Response validation if declared
                 if (route.schema?.response?.[status]) {

package/test-default-content-type.ts

@@ -1,75 +0,0 @@
-import BXO from "./src";
-
-async function testDefaultContentType() {
-    const bxo = new BXO({ serve: { port: 0 } });
-
-    // Test route that returns a string without explicit content type
-    bxo.get("/test-string", (ctx) => {
-        return "Hello World";
-    });
-
-    // Test route that returns a string with explicit content type
-    bxo.get("/test-string-explicit", (ctx) => {
-        return new Response("Hello World", {
-            headers: { "Content-Type": "text/plain" }
-        });
-    });
-
-    // Test route that uses ctx.json (should be application/json)
-    bxo.get("/test-json", (ctx) => {
-        return ctx.json({ message: "Hello World" });
-    });
-
-    // Test route that uses ctx.text (should be text/plain)
-    bxo.get("/test-text", (ctx) => {
-        return ctx.text("Hello World");
-    });
-
-    bxo.start();
-    
-    const baseUrl = `http://localhost:${bxo.server?.port}`;
-    
-    console.log("Testing default content type...");
-    
-    // Test 1: String response should default to text/html
-    try {
-        const response1 = await fetch(`${baseUrl}/test-string`);
-        const contentType1 = response1.headers.get('Content-Type');
-        console.log(`✓ String response Content-Type: ${contentType1} (should be text/html)`);
-    } catch (error) {
-        console.error("✗ Error testing string response:", error);
-    }
-
-    // Test 2: Explicit content type should be preserved
-    try {
-        const response2 = await fetch(`${baseUrl}/test-string-explicit`);
-        const contentType2 = response2.headers.get('Content-Type');
-        console.log(`✓ Explicit Content-Type: ${contentType2} (should be text/plain)`);
-    } catch (error) {
-        console.error("✗ Error testing explicit content type:", error);
-    }
-
-    // Test 3: ctx.json should be application/json
-    try {
-        const response3 = await fetch(`${baseUrl}/test-json`);
-        const contentType3 = response3.headers.get('Content-Type');
-        console.log(`✓ ctx.json Content-Type: ${contentType3} (should be application/json)`);
-    } catch (error) {
-        console.error("✗ Error testing ctx.json:", error);
-    }
-
-    // Test 4: ctx.text should be text/plain
-    try {
-        const response4 = await fetch(`${baseUrl}/test-text`);
-        const contentType4 = response4.headers.get('Content-Type');
-        console.log(`✓ ctx.text Content-Type: ${contentType4} (should be text/plain)`);
-    } catch (error) {
-        console.error("✗ Error testing ctx.text:", error);
-    }
-
-    // Close the server
-    bxo.server?.stop();
-    console.log("Test completed!");
-}
-
-testDefaultContentType().catch(console.error);