bxo 0.0.5-dev.32 → 0.0.5-dev.34

package/example.ts

@@ -0,0 +1,33 @@
+import BXO, { createCookie, redirect } from 'bxo';
+
+const app = new BXO();
+
+// 1) Explicit return redirect (302 default)
+app.get('/old', ({ redirect }) => {
+  return redirect('/new');
+});
+
+// 2) Implicit redirect (no return needed)
+app.get('/implicit', (ctx) => {
+  ctx.redirect('/new');
+});
+
+// 3) Custom status (303 after POST)
+app.post('/submit', (ctx) => {
+  // ...handle form...
+  return ctx.redirect('/thanks', 303);
+});
+
+// 4) Redirect with cookie
+app.get('/login', (ctx) => {
+  ctx.set.cookies = [
+    createCookie('sid', 'abc123', { httpOnly: true, path: '/' })
+  ];
+  ctx.redirect('/dashboard'); // no return required
+});
+
+// 5) Using top-level helper (outside ctx)
+app.get('/go-external', () => redirect('https://example.com', 307));
+
+await app.start(3000);
+console.log('Server running at http://localhost:3000');

package/index.ts

@@ -67,6 +67,7 @@ export type Context<TConfig extends RouteConfig = {}> = {
     status?: number;
     headers?: Record<string, string>;
     cookies?: Cookie[];
+    redirect?: { location: string; status?: number };
   };
   status: <T extends number>(
     code: TConfig['response'] extends StatusResponseSchema 
@@ -86,6 +87,7 @@ export type Context<TConfig extends RouteConfig = {}> = {
     : TConfig['response'] extends ResponseSchema 
       ? InferZodType<TConfig['response']>
       : any;
+  redirect: (location: string, status?: number) => Response;
   [key: string]: any;
 };
 
@@ -597,7 +599,42 @@ export default class BXO {
         status: ((code: number, data?: any) => {
           ctx.set.status = code;
           return data;
-        }) as any
+        }) as any,
+                 redirect: ((location: string, status: number = 302) => {
+           // Persist redirect intent on context so it also works without returning
+           ctx.set.status = status;
+           ctx.set.headers = {
+             ...(ctx.set.headers || {}),
+             Location: location
+           };
+           ctx.set.redirect = { location, status };
+
+           // Prepare headers for immediate Response return (merging any existing headers)
+           const responseHeaders: Record<string, string> = { ...ctx.set.headers };
+
+           // Handle cookies if any are set on context
+           if (ctx.set.cookies && ctx.set.cookies.length > 0) {
+             const cookieHeaders = ctx.set.cookies.map(cookie => {
+               let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+               if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+               if (cookie.path) cookieString += `; Path=${cookie.path}`;
+               if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+               if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+               if (cookie.secure) cookieString += `; Secure`;
+               if (cookie.httpOnly) cookieString += `; HttpOnly`;
+               if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+               return cookieString;
+             });
+             cookieHeaders.forEach((cookieHeader, index) => {
+               responseHeaders[index === 0 ? 'Set-Cookie' : `Set-Cookie-${index}`] = cookieHeader;
+             });
+           }
+
+           return new Response(null, {
+             status,
+             headers: responseHeaders
+           });
+         }) as any
       };
     } catch (validationError) {
       // Validation failed - return error response
@@ -654,6 +691,47 @@ export default class BXO {
         }
       }
 
+      // If the handler did not return a response, but a redirect was configured via ctx.set,
+      // automatically create a redirect Response so users can call ctx.redirect(...) or set headers without returning.
+      const hasImplicitRedirectIntent = !!ctx.set.redirect 
+        || (typeof ctx.set.status === 'number' && ctx.set.status >= 300 && ctx.set.status < 400);
+      if ((response === undefined || response === null) && hasImplicitRedirectIntent) {
+        const locationFromHeaders = ctx.set.headers && Object.entries(ctx.set.headers).find(([k]) => k.toLowerCase() === 'location')?.[1];
+        const location = ctx.set.redirect?.location || locationFromHeaders;
+        if (location) {
+          // Build headers, ensuring Location is present
+          let responseHeaders: Record<string, string> = ctx.set.headers ? { ...ctx.set.headers } : {};
+          if (!Object.keys(responseHeaders).some(k => k.toLowerCase() === 'location')) {
+            responseHeaders['Location'] = location;
+          }
+          // Determine status precedence: redirect.status > set.status > 302
+          const status = ctx.set.redirect?.status ?? ctx.set.status ?? 302;
+
+          // Handle cookies if any are set
+          if (ctx.set.cookies && ctx.set.cookies.length > 0) {
+            const cookieHeaders = ctx.set.cookies.map(cookie => {
+              let cookieString = `${encodeURIComponent(cookie.name)}=${encodeURIComponent(cookie.value)}`;
+              if (cookie.domain) cookieString += `; Domain=${cookie.domain}`;
+              if (cookie.path) cookieString += `; Path=${cookie.path}`;
+              if (cookie.expires) cookieString += `; Expires=${cookie.expires.toUTCString()}`;
+              if (cookie.maxAge) cookieString += `; Max-Age=${cookie.maxAge}`;
+              if (cookie.secure) cookieString += `; Secure`;
+              if (cookie.httpOnly) cookieString += `; HttpOnly`;
+              if (cookie.sameSite) cookieString += `; SameSite=${cookie.sameSite}`;
+              return cookieString;
+            });
+            cookieHeaders.forEach((cookieHeader, index) => {
+              responseHeaders[index === 0 ? 'Set-Cookie' : `Set-Cookie-${index}`] = cookieHeader;
+            });
+          }
+
+          return new Response(null, {
+            status,
+            headers: responseHeaders
+          });
+        }
+      }
+
       // Validate response against schema if provided
       if (this.enableValidation && route.config?.response && !(response instanceof Response)) {
         try {
@@ -1045,8 +1123,16 @@ const file = (path: string, options?: { type?: string; headers?: Record<string,
   return bunFile;
 }
 
+// Redirect helper function (like Elysia)
+const redirect = (location: string, status: number = 302) => {
+  return new Response(null, {
+    status,
+    headers: { Location: location }
+  });
+}
+
 // Export Zod for convenience
-export { z, error, file };
+export { z, error, file, redirect };
 
 // Export types for external use
 export type { RouteConfig, RouteDetail, Handler, WebSocketHandler, WSRoute, Cookie, BXOOptions };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "bxo",
   "module": "index.ts",
-  "version": "0.0.5-dev.32",
+  "version": "0.0.5-dev.34",
   "description": "A simple and lightweight web framework for Bun",
   "type": "module",
   "devDependencies": {