bxo 0.0.5-dev.8 → 0.0.5-dev.80

package/example/cookie-example.ts

@@ -0,0 +1,151 @@
+import BXO, { z } from "../src";
+
+async function main() {
+    const app = new BXO({ serve: { port: 3001 } });
+
+    // Example 1: Simple cookie setting
+    app.get("/set-simple-cookie", (ctx) => {
+        // Set a simple cookie
+        ctx.set.cookie("theme", "dark");
+        
+        return ctx.json({ message: "Simple cookie set!" });
+    });
+
+    // Example 2: Cookie with options
+    app.get("/set-secure-cookie", (ctx) => {
+        // Set a secure cookie with various options
+        ctx.set.cookie("sessionId", "abc123", {
+            httpOnly: true,
+            secure: true,
+            sameSite: "strict",
+            maxAge: 3600, // 1 hour
+            path: "/"
+        });
+        
+        return ctx.json({ message: "Secure cookie set!" });
+    });
+
+    // Example 3: Multiple cookies
+    app.get("/set-multiple-cookies", (ctx) => {
+        // Set multiple cookies
+        ctx.set.cookie("user", "john_doe", {
+            httpOnly: true,
+            maxAge: 86400 // 1 day
+        });
+        
+        ctx.set.cookie("preferences", "dark_mode", {
+            maxAge: 604800 // 1 week
+        });
+        
+        ctx.set.cookie("lastVisit", new Date().toISOString(), {
+            expires: new Date(Date.now() + 30 * 24 * 60 * 60 * 1000) // 30 days
+        });
+        
+        return ctx.json({ message: "Multiple cookies set!" });
+    });
+
+    // Example 4: Reading cookies
+    app.get("/read-cookies", (ctx) => {
+        return ctx.json({
+            message: "Current cookies:",
+            cookies: ctx.cookies,
+            theme: ctx.cookies.theme || "not set",
+            sessionId: ctx.cookies.sessionId || "not set",
+            user: ctx.cookies.user || "not set"
+        });
+    });
+
+    // Example 5: Login with cookie validation
+    app.post("/login", (ctx) => {
+        const { username, password } = ctx.body;
+        
+        // Simple validation (in real app, check against database)
+        if (username === "admin" && password === "password") {
+            // Set session cookie
+            ctx.set.cookie("sessionId", `session_${Date.now()}`, {
+                httpOnly: true,
+                secure: process.env.NODE_ENV === "production",
+                sameSite: "strict",
+                maxAge: 3600 // 1 hour
+            });
+            
+            ctx.set.cookie("username", username, {
+                maxAge: 3600
+            });
+            
+            return ctx.json({ 
+                message: "Login successful!",
+                username 
+            });
+        }
+        
+        return ctx.status(401, { error: "Invalid credentials" });
+    }, {
+        body: z.object({
+            username: z.string(),
+            password: z.string()
+        })
+    });
+
+    // Example 6: Protected route with cookie validation
+    app.get("/profile", (ctx) => {
+        const sessionId = ctx.cookies.sessionId;
+        const username = ctx.cookies.username;
+        
+        if (!sessionId) {
+            return ctx.status(401, { error: "Not authenticated" });
+        }
+        
+        return ctx.json({ 
+            message: "Welcome to your profile!",
+            username,
+            sessionId: sessionId.substring(0, 10) + "..." // Don't expose full session ID
+        });
+    }, {
+        cookies: z.object({
+            sessionId: z.string().optional(),
+            username: z.string().optional()
+        })
+    });
+
+    // Example 7: Logout (clear cookies)
+    app.post("/logout", (ctx) => {
+        // Clear cookies by setting them with maxAge: 0
+        ctx.set.cookie("sessionId", "", {
+            maxAge: 0,
+            path: "/"
+        });
+        
+        ctx.set.cookie("username", "", {
+            maxAge: 0,
+            path: "/"
+        });
+        
+        return ctx.json({ message: "Logged out successfully" });
+    });
+
+    // Example 8: Cookie with domain and path
+    app.get("/set-domain-cookie", (ctx) => {
+        ctx.set.cookie("globalPref", "enabled", {
+            domain: "localhost", // or your domain
+            path: "/api",
+            maxAge: 86400
+        });
+        
+        return ctx.json({ message: "Domain-specific cookie set!" });
+    });
+
+    app.start();
+    console.log(`Cookie example server running on http://localhost:${app.server?.port}`);
+    console.log("\nTry these endpoints:");
+    console.log("GET  /set-simple-cookie");
+    console.log("GET  /set-secure-cookie");
+    console.log("GET  /set-multiple-cookies");
+    console.log("GET  /read-cookies");
+    console.log("POST /login (with body: {\"username\": \"admin\", \"password\": \"password\"})");
+    console.log("GET  /profile");
+    console.log("POST /logout");
+    console.log("GET  /set-domain-cookie");
+}
+
+main().catch(console.error);

package/example/cors-example.ts

@@ -0,0 +1,49 @@
+import BXO from "../src/index";
+import { cors } from "../plugins";
+
+const app = new BXO();
+
+// Use the CORS plugin
+app.use(cors({
+  origin: ["http://localhost:3000", "http://localhost:3001"],
+  methods: ["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+  allowedHeaders: ["Content-Type", "Authorization"],
+  credentials: true
+}));
+
+// Add some routes
+app.get("/api/users", async (ctx) => {
+  return ctx.json([
+    { id: 1, name: "John Doe" },
+    { id: 2, name: "Jane Smith" }
+  ]);
+});
+
+app.post("/api/users", async (ctx) => {
+  const user = ctx.body as { name: string };
+  return ctx.json({ id: 3, name: user.name }, 201);
+});
+
+// Custom beforeRequest hook example
+app.beforeRequest(async (req) => {
+  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
+  return req; // Continue with the request
+});
+
+// Custom afterRequest hook example
+app.afterRequest(async (req, res) => {
+  console.log(`[${new Date().toISOString()}] Response: ${res.status}`);
+  return res; // Return the modified response
+});
+
+// Custom error handler
+app.onError(async (error, req) => {
+  console.error(`Error handling ${req.method} ${req.url}:`, error);
+  return new Response("Something went wrong", { status: 500 });
+});
+
+// Start the server
+app.start();
+
+console.log("Server running on http://localhost:3000");
+console.log("Try making a CORS request from another origin!");

package/example/index.html

@@ -0,0 +1,5 @@
+<html>
+    <body>
+        <h1>Hello, world!</h1>
+    </body>
+</html>

package/example/index.ts

@@ -0,0 +1,191 @@
+import BXO, { z } from "../src";
+import index from "./index.html";
+import { openapi } from "../plugins/openapi";
+
+async function main() {
+    const bxo = new BXO({ serve: { port: 0 } });
+
+    bxo.default("/", index);
+    bxo.default("/*", index);
+
+    // API routes with comprehensive metadata
+    bxo.get("/api/get/:id", (ctx) => {
+        return new Response(ctx.params.id + ctx.query.name, {
+            headers: {
+                "Content-Type": "text/html"
+            }
+        });
+    }, {
+        query: z.object({
+            name: z.number()
+        }),
+        response: {
+            200: z.object({
+                name: z.string()
+            })
+        },
+        detail: {
+            tags: ["API"],
+            summary: "Get data by ID",
+            description: "Retrieve data using an ID and name query parameter",
+            params: {
+                id: z.string().describe("Unique identifier for the data")
+            }
+        }
+    });
+
+    bxo.post("/api/post", (ctx) => {
+        console.log(ctx.body)
+        return new Response("Hello" + ctx.body.name, {
+            headers: {
+                "Content-Type": "text/html"
+            }
+        });
+    }, {
+        detail: {
+            tags: ["API"],
+            summary: "Create new data",
+            description: "Submit new data with name and avatar file",
+            defaultContentType: "multipart/form-data"
+        },
+        body: z.object({
+            name: z.string(),
+            avatar: z.file()
+        }),
+        response: {
+            200: z.object({
+                name: z.string()
+            }),
+            400: z.object({
+                error: z.string()
+            })
+        }
+    });
+
+    // Additional routes to showcase different features
+    bxo.get("/api/users", (ctx) => {
+        return ctx.json({ users: ["John", "Jane", "Bob"] });
+    }, {
+        detail: {
+            tags: ["Users"],
+            summary: "Get all users",
+            description: "Retrieve a list of all users in the system"
+        },
+        response: {
+            200: z.object({
+                users: z.array(z.string())
+            })
+        }
+    });
+
+    bxo.get("/api/users/:id", (ctx) => {
+        const id = ctx.params.id;
+        return ctx.json({ user: { id, name: "John Doe", email: "john@example.com" } });
+    }, {
+        detail: {
+            tags: ["Users"],
+            summary: "Get user by ID",
+            description: "Retrieve a specific user by their unique identifier",
+            params: {
+                id: z.string().describe("User's unique identifier")
+            }
+        },
+        response: {
+            200: z.object({
+                user: z.object({
+                    id: z.string(),
+                    name: z.string(),
+                    email: z.string()
+                })
+            }),
+            404: z.object({
+                error: z.string()
+            })
+        }
+    });
+
+    bxo.post("/api/users", (ctx) => {
+        const userData = ctx.body;
+        return ctx.json({ message: "User created", user: userData });
+    }, {
+        detail: {
+            tags: ["Users"],
+            summary: "Create new user",
+            description: "Create a new user account with the provided information"
+        },
+        body: z.object({
+            name: z.string().min(1, "Name is required"),
+            email: z.string().email("Invalid email format"),
+            age: z.number().min(18, "Must be at least 18 years old").optional()
+        }),
+        response: {
+            201: z.object({
+                message: z.string(),
+                user: z.object({
+                    name: z.string(),
+                    email: z.string(),
+                    age: z.number().optional()
+                })
+            }),
+            400: z.object({
+                error: z.string(),
+                issues: z.array(z.any()).optional()
+            })
+        }
+    });
+
+    // Health check route
+    bxo.get("/health", (ctx) => {
+        return ctx.json({
+            status: "ok",
+            timestamp: new Date().toISOString(),
+            uptime: process.uptime()
+        });
+    }, {
+        detail: {
+            tags: ["System"],
+            summary: "Health check",
+            description: "Check the health status of the API server"
+        },
+        response: {
+            200: z.object({
+                status: z.string(),
+                timestamp: z.string(),
+                uptime: z.number()
+            })
+        }
+    });
+
+    // Use OpenAPI plugin with enhanced configuration
+    bxo.use(openapi({
+        path: "/docs",
+        jsonPath: "/openapi.json",
+        defaultTags: ["API"],
+        securitySchemes: {
+            bearerAuth: {
+                type: "http",
+                scheme: "bearer",
+                bearerFormat: "JWT",
+                description: "JWT token for authentication"
+            },
+            apiKeyAuth: {
+                type: "apiKey",
+                in: "header",
+                name: "X-API-Key",
+                description: "API key for authentication"
+            }
+        },
+        globalSecurity: [
+            { bearerAuth: [] },
+            { apiKeyAuth: [] }
+        ],
+        openapiConfig: {}
+    }));
+
+    bxo.start();
+    console.log(`Server is running on http://localhost:${bxo.server?.port}`);
+    console.log(`OpenAPI documentation available at http://localhost:${bxo.server?.port}/docs`);
+    console.log(`OpenAPI JSON available at http://localhost:${bxo.server?.port}/openapi.json`);
+}
+
+main();

package/example/multipart-example.ts

@@ -0,0 +1,203 @@
+import BXO from "../src/index";
+import { z } from "zod";
+
+const app = new BXO();
+
+// Define Zod schema for the form data structure
+const UserFormSchema = z.object({
+  name: z.string(),
+  email: z.string().email(),
+  password: z.string().min(6),
+  is_active: z.string().transform(val => val === "1"),
+  profile: z.object({
+    name: z.string()
+  }),
+  id: z.string().optional(),
+  created_at: z.string().optional(),
+  updated_at: z.string().optional(),
+  idx: z.string().transform(val => parseInt(val, 10))
+});
+
+// Route to handle multipart/form-data with nested objects
+app.post("/users", async (ctx) => {
+  // The form data is automatically parsed into nested objects
+  // ctx.body will contain the structured data based on the schema
+  console.log("Parsed form data:", ctx.body);
+  
+  return ctx.json({
+    message: "User created successfully",
+    data: ctx.body
+  });
+}, {
+  body: UserFormSchema,
+  detail: {
+    summary: "Create user with multipart/form-data",
+    description: "Handles form data with nested objects and arrays",
+    tags: ["Users"]
+  }
+});
+
+// Example with arrays
+const ArrayFormSchema = z.object({
+  items: z.array(z.string()),
+  tags: z.array(z.string()),
+  profile: z.object({
+    name: z.string(),
+    age: z.string().transform(val => parseInt(val, 10))
+  })
+});
+
+app.post("/items", async (ctx) => {
+  console.log("Parsed array form data:", ctx.body);
+  
+  return ctx.json({
+    message: "Items processed successfully",
+    data: ctx.body
+  });
+}, {
+  body: ArrayFormSchema,
+  detail: {
+    summary: "Process items with arrays",
+    description: "Handles form data with arrays like items[0], items[1]",
+    tags: ["Items"]
+  }
+});
+
+// Test route to show how the parsing works
+app.get("/test-parsing", async (ctx) => {
+  const html = `
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Multipart Form Data Test</title>
+    <style>
+        body { font-family: Arial, sans-serif; margin: 40px; }
+        .form-group { margin: 20px 0; }
+        label { display: block; margin-bottom: 5px; font-weight: bold; }
+        input, textarea { width: 300px; padding: 8px; margin-bottom: 10px; }
+        button { background: #007bff; color: white; padding: 10px 20px; border: none; cursor: pointer; }
+        .result { margin-top: 20px; padding: 20px; background: #f8f9fa; border-radius: 5px; }
+    </style>
+</head>
+<body>
+    <h1>Multipart Form Data Parsing Test</h1>
+    
+    <h2>Test 1: Nested Objects (like your image example)</h2>
+    <form id="userForm" enctype="multipart/form-data">
+        <div class="form-group">
+            <label>Name:</label>
+            <input type="text" name="name" value="John Doe" required>
+        </div>
+        <div class="form-group">
+            <label>Email:</label>
+            <input type="email" name="email" value="john@example.com" required>
+        </div>
+        <div class="form-group">
+            <label>Password:</label>
+            <input type="password" name="password" value="password123" required>
+        </div>
+        <div class="form-group">
+            <label>Is Active:</label>
+            <input type="text" name="is_active" value="1">
+        </div>
+        <div class="form-group">
+            <label>Profile Name:</label>
+            <input type="text" name="profile[name]" value="John Profile" required>
+        </div>
+        <div class="form-group">
+            <label>ID:</label>
+            <input type="text" name="id" value="UUID()">
+        </div>
+        <div class="form-group">
+            <label>Created At:</label>
+            <input type="text" name="created_at" value="NOW()">
+        </div>
+        <div class="form-group">
+            <label>Updated At:</label>
+            <input type="text" name="updated_at" value="NOW()">
+        </div>
+        <div class="form-group">
+            <label>Index:</label>
+            <input type="text" name="idx" value="0">
+        </div>
+        <button type="submit">Submit User Form</button>
+    </form>
+    
+    <h2>Test 2: Arrays</h2>
+    <form id="itemsForm" enctype="multipart/form-data">
+        <div class="form-group">
+            <label>Item 1:</label>
+            <input type="text" name="items[0]" value="Apple">
+        </div>
+        <div class="form-group">
+            <label>Item 2:</label>
+            <input type="text" name="items[1]" value="Banana">
+        </div>
+        <div class="form-group">
+            <label>Item 3:</label>
+            <input type="text" name="items[2]" value="Cherry">
+        </div>
+        <div class="form-group">
+            <label>Tag 1:</label>
+            <input type="text" name="tags[0]" value="fruit">
+        </div>
+        <div class="form-group">
+            <label>Tag 2:</label>
+            <input type="text" name="tags[1]" value="healthy">
+        </div>
+        <div class="form-group">
+            <label>Profile Name:</label>
+            <input type="text" name="profile[name]" value="Test Profile">
+        </div>
+        <div class="form-group">
+            <label>Profile Age:</label>
+            <input type="text" name="profile[age]" value="25">
+        </div>
+        <button type="submit">Submit Items Form</button>
+    </form>
+    
+    <div id="result" class="result" style="display: none;">
+        <h3>Result:</h3>
+        <pre id="resultContent"></pre>
+    </div>
+
+    <script>
+        async function submitForm(form, endpoint) {
+            const formData = new FormData(form);
+            try {
+                const response = await fetch(endpoint, {
+                    method: 'POST',
+                    body: formData
+                });
+                const result = await response.json();
+                document.getElementById('result').style.display = 'block';
+                document.getElementById('resultContent').textContent = JSON.stringify(result, null, 2);
+            } catch (error) {
+                document.getElementById('result').style.display = 'block';
+                document.getElementById('resultContent').textContent = 'Error: ' + error.message;
+            }
+        }
+        
+        document.getElementById('userForm').addEventListener('submit', (e) => {
+            e.preventDefault();
+            submitForm(e.target, '/users');
+        });
+        
+        document.getElementById('itemsForm').addEventListener('submit', (e) => {
+            e.preventDefault();
+            submitForm(e.target, '/items');
+        });
+    </script>
+</body>
+</html>
+  `;
+  
+  return new Response(html, {
+    headers: { "Content-Type": "text/html" }
+  });
+});
+
+app.start();
+
+console.log("🚀 Server running at http://localhost:3000");
+console.log("📝 Test the multipart parsing at http://localhost:3000/test-parsing");