bxo 0.0.10-dev.2 → 0.0.10-dev.3

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/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.3",
   "type": "module",
   "devDependencies": {
     "@types/bun": "latest"

package/src/index.ts

@@ -195,11 +195,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;

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);