bxo 0.0.5-dev.83 → 0.0.5-dev.85

package/example/multipart-example.ts

@@ -5,107 +5,107 @@ 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))
+    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
-  });
+    // 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"]
-  }
+    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))
-  })
+    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
-  });
+    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"]
-  }
+    body: ArrayFormSchema,
+    detail: {
+        summary: "Process items with arrays",
+        description: "Handles form data with arrays like items[0], items[1]",
+        tags: ["Items"]
+    }
 });
 
 // Example with deep nested array objects (like workspace_items[0][id])
 const WorkspaceFormSchema = z.object({
-  id: z.string(),
-  created_at: z.string(),
-  updated_at: z.string(),
-  updated_by: z.string(),
-  doc_status: z.string().transform(val => parseInt(val, 10)),
-  idx: z.string().transform(val => parseInt(val, 10)),
-  workspace_items: z.array(z.object({
     id: z.string(),
-    type: z.string(),
-    value: z.string(),
-    options: z.string(),
-    workspaceId: z.string(),
-    owner: z.string(),
     created_at: z.string(),
     updated_at: z.string(),
-    created_by: z.string(),
     updated_by: z.string(),
     doc_status: z.string().transform(val => parseInt(val, 10)),
-    label: z.string()
-  }))
+    idx: z.string().transform(val => parseInt(val, 10)),
+    workspace_items: z.array(z.object({
+        id: z.string(),
+        type: z.string(),
+        value: z.string(),
+        options: z.string(),
+        workspaceId: z.string(),
+        owner: z.string(),
+        created_at: z.string(),
+        updated_at: z.string(),
+        created_by: z.string(),
+        updated_by: z.string(),
+        doc_status: z.string().transform(val => parseInt(val, 10)),
+        label: z.string()
+    }))
 });
 
 app.post("/workspace", async (ctx) => {
-  console.log("Parsed workspace form data:", ctx.body);
-  
-  return ctx.json({
-    message: "Workspace processed successfully",
-    data: ctx.body
-  });
+    console.log("Parsed workspace form data:", ctx.body);
+
+    return ctx.json({
+        message: "Workspace processed successfully",
+        data: ctx.body
+    });
 }, {
-  body: WorkspaceFormSchema,
-  detail: {
-    summary: "Process workspace with deep nested array objects",
-    description: "Handles form data like workspace_items[0][id], workspace_items[0][type]",
-    tags: ["Workspace"]
-  }
+    body: WorkspaceFormSchema,
+    detail: {
+        summary: "Process workspace with deep nested array objects",
+        description: "Handles form data like workspace_items[0][id], workspace_items[0][type]",
+        tags: ["Workspace"]
+    }
 });
 
 // Test route to show how the parsing works
 app.get("/test-parsing", async (ctx) => {
-  const html = `
+    const html = `
 <!DOCTYPE html>
 <html>
 <head>
@@ -310,10 +310,17 @@ app.get("/test-parsing", async (ctx) => {
 </body>
 </html>
   `;
-  
-  return new Response(html, {
-    headers: { "Content-Type": "text/html" }
-  });
+
+    return new Response(html, {
+        headers: { "Content-Type": "text/html" }
+    });
+});
+
+app.get("/test-file", async (ctx) => {
+    if (!ctx.query.file) {
+        return new Response("File not found", { status: 404 });
+    }
+    return Bun.file("test.txt");
 });
 
 app.start();

package/example/redirect-documentation.md

@@ -0,0 +1,298 @@
+# Redirect Functionality in BXO
+
+BXO provides multiple ways to handle HTTP redirects in your applications. This guide covers all the available methods and best practices.
+
+## Available Redirect Methods
+
+### 1. Using the `ctx.redirect()` Helper (Recommended)
+
+The most convenient way to return redirects is using the built-in `ctx.redirect()` method:
+
+```typescript
+app.get("/old-page", (ctx) => {
+    return ctx.redirect("/new-page"); // Default: 302 status
+});
+
+app.get("/permanent-redirect", (ctx) => {
+    return ctx.redirect("/new-location", 301); // Permanent redirect
+});
+```
+
+### 2. Using Standard Response with Location Header
+
+For more control over headers, use the standard Response API:
+
+```typescript
+app.get("/custom-redirect", (ctx) => {
+    return new Response(null, {
+        status: 302,
+        headers: {
+            "Location": "/target",
+            "Cache-Control": "no-cache"
+        }
+    });
+});
+```
+
+### 3. Using Context Status Method
+
+You can also use the existing `ctx.status()` method with manual header setting:
+
+```typescript
+app.get("/manual-redirect", (ctx) => {
+    ctx.set.headers["Location"] = "/target";
+    return ctx.status(302, null);
+});
+```
+
+## HTTP Redirect Status Codes
+
+BXO supports all standard HTTP redirect status codes:
+
+| Status | Code | Name | Description | Method Preservation |
+|--------|------|------|-------------|-------------------|
+| 301 | 301 | Moved Permanently | Resource has permanently moved | No |
+| 302 | 302 | Found | Temporary redirect (default) | No |
+| 303 | 303 | See Other | Forces GET method after POST | No |
+| 307 | 307 | Temporary Redirect | Preserves original method | Yes |
+| 308 | 308 | Permanent Redirect | Preserves original method | Yes |
+
+## Common Use Cases
+
+### 1. Page Migration (301)
+```typescript
+app.get("/old-url", (ctx) => {
+    return ctx.redirect("/new-url", 301);
+});
+```
+
+### 2. Post-Redirect-Get Pattern (303)
+```typescript
+app.post("/form-submit", (ctx) => {
+    // Process form data
+    return ctx.redirect("/success", 303); // Forces GET
+});
+```
+
+### 3. API Endpoint Migration (307)
+```typescript
+app.put("/api/old-endpoint", (ctx) => {
+    return ctx.redirect("/api/new-endpoint", 307); // Preserves PUT method
+});
+```
+
+### 4. Conditional Redirects
+```typescript
+app.get("/dashboard", (ctx) => {
+    const userType = ctx.cookies.userType;
+    
+    if (userType === "admin") {
+        return ctx.redirect("/admin-dashboard", 302);
+    } else {
+        return ctx.redirect("/user-dashboard", 302);
+    }
+});
+```
+
+### 5. Query Parameter Preservation
+```typescript
+app.get("/search", (ctx) => {
+    const queryString = new URLSearchParams(ctx.query).toString();
+    const redirectUrl = queryString ? `/new-search?${queryString}` : "/new-search";
+    return ctx.redirect(redirectUrl, 301);
+});
+```
+
+### 6. Authentication Redirects
+```typescript
+app.get("/protected", (ctx) => {
+    const session = ctx.cookies.session;
+    
+    if (!session) {
+        return ctx.redirect("/login", 302);
+    }
+    
+    return ctx.json({ message: "Protected content" });
+});
+```
+
+## Best Practices
+
+### 1. Choose the Right Status Code
+- **301**: Use for permanent moves (SEO-friendly)
+- **302**: Use for temporary redirects (default)
+- **303**: Use after POST to prevent resubmission
+- **307/308**: Use for API endpoints to preserve HTTP methods
+
+### 2. Handle Relative vs Absolute URLs
+```typescript
+// Relative URL (stays on same domain)
+ctx.redirect("/new-path", 302);
+
+// Absolute URL (can redirect to different domain)
+ctx.redirect("https://example.com/new-path", 301);
+```
+
+### 3. Preserve Query Parameters When Needed
+```typescript
+app.get("/old-search", (ctx) => {
+    const { q, page, filters } = ctx.query;
+    const params = new URLSearchParams(ctx.query);
+    const redirectUrl = params.toString() ? `/new-search?${params}` : "/new-search";
+    return ctx.redirect(redirectUrl, 301);
+});
+```
+
+### 4. Add Custom Headers When Necessary
+```typescript
+app.get("/redirect-with-cache", (ctx) => {
+    return new Response(null, {
+        status: 301,
+        headers: {
+            "Location": "/new-location",
+            "Cache-Control": "public, max-age=3600"
+        }
+    });
+});
+```
+
+## Testing Redirects
+
+### Using curl
+```bash
+# Check redirect status and location
+curl -I http://localhost:3000/old-page
+
+# Follow redirects automatically
+curl -L http://localhost:3000/old-page
+
+# Test with different HTTP methods
+curl -X POST http://localhost:3000/form-submit
+curl -X PUT http://localhost:3000/api/update
+```
+
+### Using JavaScript fetch
+```javascript
+// Don't follow redirects automatically
+fetch('/old-page', { redirect: 'manual' })
+  .then(response => {
+    console.log('Status:', response.status);
+    console.log('Location:', response.headers.get('Location'));
+  });
+
+// Follow redirects automatically (default)
+fetch('/old-page')
+  .then(response => response.text())
+  .then(data => console.log(data));
+```
+
+## Common Patterns
+
+### 1. URL Shortening
+```typescript
+app.get("/s/:shortId", (ctx) => {
+    const { shortId } = ctx.params;
+    const longUrl = getLongUrl(shortId); // Your database lookup
+    return ctx.redirect(longUrl, 302);
+});
+```
+
+### 2. Language/Region Redirects
+```typescript
+app.get("/", (ctx) => {
+    const acceptLanguage = ctx.headers["accept-language"];
+    const region = detectRegion(acceptLanguage);
+    return ctx.redirect(`/${region}/home`, 302);
+});
+```
+
+### 3. Maintenance Mode
+```typescript
+app.get("*", (ctx) => {
+    if (isMaintenanceMode()) {
+        return ctx.redirect("/maintenance", 503);
+    }
+    // Continue with normal routing
+});
+```
+
+### 4. HTTPS Redirect
+```typescript
+app.get("*", (ctx) => {
+    if (ctx.request.url.startsWith("http://") && isProduction()) {
+        const httpsUrl = ctx.request.url.replace("http://", "https://");
+        return ctx.redirect(httpsUrl, 301);
+    }
+    // Continue with normal routing
+});
+```
+
+## Error Handling
+
+### 1. Invalid Redirect URLs
+```typescript
+app.get("/redirect", (ctx) => {
+    const { url } = ctx.query;
+    
+    if (!url || !isValidUrl(url)) {
+        return ctx.status(400, { error: "Invalid redirect URL" });
+    }
+    
+    return ctx.redirect(url, 302);
+});
+```
+
+### 2. Redirect Loops Prevention
+```typescript
+app.get("/redirect", (ctx) => {
+    const redirectCount = parseInt(ctx.headers["x-redirect-count"] || "0");
+    
+    if (redirectCount > 5) {
+        return ctx.status(400, { error: "Too many redirects" });
+    }
+    
+    // Add redirect count header
+    ctx.set.headers["x-redirect-count"] = (redirectCount + 1).toString();
+    return ctx.redirect("/target", 302);
+});
+```
+
+## Performance Considerations
+
+1. **Minimize Redirect Chains**: Avoid multiple redirects in sequence
+2. **Use 301 for Permanent Moves**: Helps with SEO and caching
+3. **Consider CDN Caching**: Some CDNs cache redirects based on status codes
+4. **Monitor Redirect Performance**: Track redirect success rates and response times
+
+## Security Considerations
+
+1. **Validate Redirect URLs**: Prevent open redirect vulnerabilities
+2. **Use HTTPS**: Always redirect to HTTPS in production
+3. **Sanitize User Input**: Clean any user-provided redirect URLs
+4. **Implement Rate Limiting**: Prevent redirect abuse
+
+```typescript
+app.get("/redirect", (ctx) => {
+    const { url } = ctx.query;
+    
+    // Security: Validate redirect URL
+    if (!url || !isAllowedRedirect(url)) {
+        return ctx.status(400, { error: "Invalid redirect URL" });
+    }
+    
+    return ctx.redirect(url, 302);
+});
+
+function isAllowedRedirect(url: string): boolean {
+    try {
+        const parsedUrl = new URL(url);
+        // Only allow redirects to same domain or trusted domains
+        return parsedUrl.hostname === "localhost" || 
+               parsedUrl.hostname === "example.com";
+    } catch {
+        return false;
+    }
+}
+```
+
+This comprehensive guide should help you implement redirects effectively in your BXO applications!

package/example/redirect-example.ts

@@ -0,0 +1,222 @@
+import BXO from "../src";
+
+async function main() {
+    const app = new BXO({ serve: { port: 3002 } });
+
+    // Example 1: Simple temporary redirect (302) - default
+    app.get("/old-page", (ctx) => {
+        return ctx.redirect("/new-page");
+    });
+
+    // Example 2: Permanent redirect (301)
+    app.get("/permanent-redirect", (ctx) => {
+        return ctx.redirect("/new-location", 301);
+    });
+
+    // Example 3: Temporary redirect (302) - explicit
+    app.get("/temp-redirect", (ctx) => {
+        return ctx.redirect("/target", 302);
+    });
+
+    // Example 4: See Other redirect (303) - forces GET method
+    app.post("/form-submit", (ctx) => {
+        // After POST, redirect to success page with GET
+        return ctx.redirect("/success", 303);
+    });
+
+    // Example 5: Temporary redirect preserving method (307)
+    app.put("/api/update", (ctx) => {
+        // Preserves PUT method in redirect
+        return ctx.redirect("/api/updated", 307);
+    });
+
+    // Example 6: Permanent redirect preserving method (308)
+    app.patch("/api/patch", (ctx) => {
+        // Preserves PATCH method in redirect
+        return ctx.redirect("/api/patched", 308);
+    });
+
+    // Example 7: External redirect
+    app.get("/external", (ctx) => {
+        return ctx.redirect("https://example.com", 301);
+    });
+
+    // Example 8: Conditional redirect based on query parameters
+    app.get("/conditional", (ctx) => {
+        const { type } = ctx.query;
+        
+        if (type === "admin") {
+            return ctx.redirect("/admin-dashboard", 302);
+        } else if (type === "user") {
+            return ctx.redirect("/user-dashboard", 302);
+        } else {
+            return ctx.redirect("/default-page", 302);
+        }
+    });
+
+    // Example 9: Redirect with path parameters
+    app.get("/user/:id", (ctx) => {
+        const { id } = ctx.params;
+        return ctx.redirect(`/profile/${id}`, 301);
+    });
+
+    // Example 10: Redirect with query string preservation
+    app.get("/search", (ctx) => {
+        const { q, page } = ctx.query;
+        const queryString = new URLSearchParams(ctx.query).toString();
+        const redirectUrl = queryString ? `/new-search?${queryString}` : "/new-search";
+        return ctx.redirect(redirectUrl, 301);
+    });
+
+    // Example 11: Redirect with custom headers
+    app.get("/custom-redirect", (ctx) => {
+        // You can still use the standard Response approach for custom headers
+        return new Response(null, {
+            status: 302,
+            headers: {
+                "Location": "/target",
+                "Cache-Control": "no-cache",
+                "X-Custom-Header": "redirect-value"
+            }
+        });
+    });
+
+    // Example 12: Redirect after authentication
+    app.post("/login", (ctx) => {
+        const { username, password } = ctx.body;
+        
+        // Simple authentication check
+        if (username === "admin" && password === "password") {
+            // Set session cookie
+            ctx.set.cookie("session", "authenticated", {
+                httpOnly: true,
+                maxAge: 3600
+            });
+            
+            // Redirect to dashboard
+            return ctx.redirect("/dashboard", 303);
+        } else {
+            // Redirect back to login with error
+            return ctx.redirect("/login?error=invalid-credentials", 303);
+        }
+    });
+
+    // Example 13: Redirect with status code validation
+    app.get("/validated-redirect", (ctx) => {
+        const { status } = ctx.query;
+        
+        // Validate status code
+        const validStatuses = [301, 302, 303, 307, 308];
+        const redirectStatus = validStatuses.includes(Number(status)) ? Number(status) : 302;
+        
+        return ctx.redirect("/target", redirectStatus as 301 | 302 | 303 | 307 | 308);
+    });
+
+    // Example 14: Redirect with relative and absolute URLs
+    app.get("/relative-redirect", (ctx) => {
+        // Relative URL redirect
+        return ctx.redirect("./relative-path", 302);
+    });
+
+    app.get("/absolute-redirect", (ctx) => {
+        // Absolute URL redirect
+        return ctx.redirect("/absolute-path", 302);
+    });
+
+    // Example 15: Redirect with fragment (hash)
+    app.get("/fragment-redirect", (ctx) => {
+        return ctx.redirect("/page#section", 302);
+    });
+
+    // Target pages for testing redirects
+    app.get("/new-page", (ctx) => {
+        return ctx.json({ message: "Welcome to the new page!" });
+    });
+
+    app.get("/new-location", (ctx) => {
+        return ctx.json({ message: "This is the new permanent location!" });
+    });
+
+    app.get("/target", (ctx) => {
+        return ctx.json({ message: "Redirect target reached!" });
+    });
+
+    app.get("/success", (ctx) => {
+        return ctx.json({ message: "Form submitted successfully!" });
+    });
+
+    app.get("/dashboard", (ctx) => {
+        const session = ctx.cookies.session;
+        if (session === "authenticated") {
+            return ctx.json({ message: "Welcome to the dashboard!" });
+        } else {
+            return ctx.redirect("/login", 302);
+        }
+    });
+
+    app.get("/login", (ctx) => {
+        const { error } = ctx.query;
+        return ctx.json({ 
+            message: "Login page",
+            error: error || null
+        });
+    });
+
+    app.get("/new-search", (ctx) => {
+        return ctx.json({ 
+            message: "New search page",
+            query: ctx.query
+        });
+    });
+
+    app.get("/profile/:id", (ctx) => {
+        return ctx.json({ 
+            message: `Profile page for user ${ctx.params.id}`
+        });
+    });
+
+    app.get("/admin-dashboard", (ctx) => {
+        return ctx.json({ message: "Admin dashboard" });
+    });
+
+    app.get("/user-dashboard", (ctx) => {
+        return ctx.json({ message: "User dashboard" });
+    });
+
+    app.get("/default-page", (ctx) => {
+        return ctx.json({ message: "Default page" });
+    });
+
+    app.get("/page", (ctx) => {
+        return ctx.json({ message: "Page with section" });
+    });
+
+    app.start();
+    console.log(`Redirect example server running on http://localhost:${app.server?.port}`);
+    console.log("\nTry these redirect endpoints:");
+    console.log("GET  /old-page                    -> /new-page (302)");
+    console.log("GET  /permanent-redirect          -> /new-location (301)");
+    console.log("GET  /temp-redirect               -> /target (302)");
+    console.log("POST /form-submit                -> /success (303)");
+    console.log("PUT  /api/update                 -> /api/updated (307)");
+    console.log("PATCH /api/patch                 -> /api/patched (308)");
+    console.log("GET  /external                   -> https://example.com (301)");
+    console.log("GET  /conditional?type=admin     -> /admin-dashboard (302)");
+    console.log("GET  /conditional?type=user       -> /user-dashboard (302)");
+    console.log("GET  /conditional                -> /default-page (302)");
+    console.log("GET  /user/123                   -> /profile/123 (301)");
+    console.log("GET  /search?q=test&page=1        -> /new-search?q=test&page=1 (301)");
+    console.log("GET  /custom-redirect             -> /target (302) with custom headers");
+    console.log("POST /login (admin/password)     -> /dashboard (303)");
+    console.log("GET  /validated-redirect?status=301 -> /target (301)");
+    console.log("GET  /relative-redirect           -> ./relative-path (302)");
+    console.log("GET  /absolute-redirect           -> /absolute-path (302)");
+    console.log("GET  /fragment-redirect          -> /page#section (302)");
+    console.log("\nTest with curl:");
+    console.log("curl -I http://localhost:3002/old-page");
+    console.log("curl -I http://localhost:3002/permanent-redirect");
+    console.log("curl -X POST http://localhost:3002/form-submit");
+    console.log("curl -X PUT http://localhost:3002/api/update");
+}
+
+main().catch(console.error);

package/package.json

@@ -5,12 +5,13 @@
     ".": "./src/index.ts",
     "./plugins": "./plugins/index.ts"
   },
-  "version": "0.0.5-dev.83",
+  "version": "0.0.5-dev.85",
   "type": "module",
   "devDependencies": {
     "@types/bun": "latest"
   },
   "peerDependencies": {
+    "axios": "^1.12.2",
     "typescript": "^5"
   },
   "dependencies": {

package/src/index.ts

@@ -83,9 +83,10 @@ export type Context<P extends string = string, S extends RouteSchema | undefined
     json: <T>(data: T, status?: number) => Response;
     text: (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;
 };
 
-type AnyHandler = (ctx: Context<any, any>, app: BXO) => Response | string | Promise<Response | string>;
+type AnyHandler = (ctx: Context<any, any>, app: BXO) => Response | string | BunFile | Promise<Response | string | BunFile>;
 type Handler<P extends string, S extends RouteSchema | undefined = undefined> = (
     ctx: Context<P, S>,
     app: BXO
@@ -757,6 +758,14 @@ export default class BXO {
                 }
 
                 return toResponse(data, { status });
+            },
+            redirect: (url, status = 302) => {
+                return new Response(null, {
+                    status,
+                    headers: {
+                        "Location": url
+                    }
+                });
             }
         };
 

package/test-url-encoding.ts

@@ -1,21 +0,0 @@
-import BXO from "./src";
-
-const app = new BXO({ serve: { port: 3001 } });
-
-// Test the exact scenario you mentioned
-app.get("/api/resources/:resourceType/:id", (ctx) => {
-    return ctx.json({
-        message: "Success!",
-        resourceType: ctx.params.resourceType,
-        id: ctx.params.id,
-        allParams: ctx.params,
-        url: ctx.request.url,
-        pathname: new URL(ctx.request.url).pathname
-    });
-});
-
-app.start();
-console.log(`Test server running on http://localhost:${app.server?.port}`);
-console.log(`Test URL: http://localhost:${app.server?.port}/api/resources/Doctype%20Permission/01992af8-1c69-7000-9219-9b83c2feb2d6`);
-
-