bxo 0.0.5-dev.22 → 0.0.5-dev.24

package/README.md

@@ -93,11 +93,86 @@ interface Context<TConfig> {
     status?: number;
     headers?: Record<string, string>;
   };
+  status: (code: number, data?: any) => any;  // Type-safe status method
   user?: any;                    // Added by auth plugin
   [key: string]: any;            // Extended by plugins
 }
 ```
 
+### Type-Safe Status Method
+
+BXO provides a type-safe `ctx.status()` method similar to Elysia, which allows you to set HTTP status codes and return data in one call:
+
+```typescript
+// Simple usage
+app.get('/hello', (ctx) => {
+  return ctx.status(200, { message: 'Hello World' });
+});
+
+// With response validation
+app.get('/user/:id', (ctx) => {
+  const userId = ctx.params.id;
+  
+  if (userId === 'not-found') {
+    // TypeScript suggests 404 as valid status
+    return ctx.status(404, { error: 'User not found' });
+  }
+  
+  // TypeScript suggests 200 as valid status
+  return ctx.status(200, { user: { id: userId, name: 'John Doe' } });
+}, {
+  response: {
+    200: z.object({
+      user: z.object({
+        id: z.string(),
+        name: z.string()
+      })
+    }),
+    404: z.object({
+      error: z.string()
+    })
+  }
+});
+
+// POST with validation and status responses
+app.post('/users', (ctx) => {
+  const { name, email } = ctx.body;
+  
+  if (!name || !email) {
+    return ctx.status(400, { error: 'Missing required fields' });
+  }
+  
+  return ctx.status(201, { 
+    success: true, 
+    user: { id: 1, name, email } 
+  });
+}, {
+  body: z.object({
+    name: z.string(),
+    email: z.string().email()
+  }),
+  response: {
+    201: z.object({
+      success: z.boolean(),
+      user: z.object({
+        id: z.number(),
+        name: z.string(),
+        email: z.string()
+      })
+    }),
+    400: z.object({
+      error: z.string()
+    })
+  }
+});
+```
+
+**Key Features:**
+- **Type Safety**: Status codes are suggested based on your response configuration
+- **Data Validation**: Return data is validated against the corresponding schema
+- **Autocomplete**: TypeScript provides autocomplete for valid status codes
+- **Return Type Inference**: Return types are properly inferred from schemas
+
 ### Validation Configuration
 
 Each route can specify validation schemas for different parts of the request:

package/index.ts

@@ -51,6 +51,9 @@ interface RouteConfig {
   detail?: RouteDetail;
 }
 
+// Helper type to extract status codes from response config
+type StatusCodes<T> = T extends Record<number, any> ? keyof T : never;
+
 // Context type that's fully typed based on the route configuration
 export type Context<TConfig extends RouteConfig = {}> = {
   params: TConfig['params'] extends z.ZodSchema<any> ? InferZodType<TConfig['params']> : Record<string, string>;
@@ -65,12 +68,29 @@ export type Context<TConfig extends RouteConfig = {}> = {
     headers?: Record<string, string>;
     cookies?: Cookie[];
   };
-  status: (code: number, data?: any) => any;
+  status: <T extends number>(
+    code: TConfig['response'] extends StatusResponseSchema 
+      ? StatusCodes<TConfig['response']> | number
+      : T,
+    data?: TConfig['response'] extends StatusResponseSchema 
+      ? T extends keyof TConfig['response'] 
+        ? InferZodType<TConfig['response'][T]>
+        : any
+      : TConfig['response'] extends ResponseSchema 
+        ? InferZodType<TConfig['response']>
+        : any
+  ) => TConfig['response'] extends StatusResponseSchema 
+    ? T extends keyof TConfig['response'] 
+      ? InferZodType<TConfig['response'][T]>
+      : any
+    : TConfig['response'] extends ResponseSchema 
+      ? InferZodType<TConfig['response']>
+      : any;
   [key: string]: any;
 };
 
 // Handler function type with proper response typing
-type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<InferResponseType<TConfig['response']> | any> | InferResponseType<TConfig['response']> | any;
+type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<InferResponseType<TConfig['response']>> | InferResponseType<TConfig['response']>;
 
 // Route definition
 interface Route {
@@ -408,18 +428,18 @@ export default class BXO {
   // Parse query string
   private parseQuery(searchParams: URLSearchParams): Record<string, string | undefined> {
     const query: Record<string, string | undefined> = {};
-    for (const [key, value] of searchParams.entries()) {
+    searchParams.forEach((value, key) => {
       query[key] = value;
-    }
+    });
     return query;
   }
 
   // Parse headers
   private parseHeaders(headers: Headers): Record<string, string> {
     const headerObj: Record<string, string> = {};
-    for (const [key, value] of headers.entries()) {
+    headers.forEach((value, key) => {
       headerObj[key] = value;
-    }
+    });
     return headerObj;
   }
 
@@ -560,10 +580,10 @@ export default class BXO {
         path: pathname,
         request,
         set: {},
-        status: (code: number, data?: any) => {
+        status: ((code: number, data?: any) => {
           ctx.set.status = code;
           return data;
-        }
+        }) as any
       };
     } catch (validationError) {
       // Validation failed - return error response
@@ -623,7 +643,6 @@ export default class BXO {
       // Validate response against schema if provided
       if (route.config?.response && !(response instanceof Response)) {
         try {
-          console.log('response', response);
           const status = ctx.set.status || 200;
           response = this.validateResponse(route.config.response, response, status);
         } catch (validationError) {

package/package.json

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