bxo 0.0.5-dev.21 → 0.0.5-dev.23

package/README.md

@@ -20,7 +20,7 @@ BXO is a fast, lightweight, and fully type-safe web framework built specifically
 ### Installation
 
 ```bash
-bun add zod
+bun add bxo
 ```
 
 ### Basic Usage
@@ -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

@@ -3,6 +3,18 @@ import { z } from 'zod';
 // Type utilities for extracting types from Zod schemas
 type InferZodType<T> = T extends z.ZodType<infer U> ? U : never;
 
+// Response configuration types
+type ResponseSchema = z.ZodSchema<any>;
+type StatusResponseSchema = Record<number, ResponseSchema>;
+type ResponseConfig = ResponseSchema | StatusResponseSchema;
+
+// Type utility to extract response type from response config
+type InferResponseType<T> = T extends ResponseSchema 
+  ? InferZodType<T>
+  : T extends StatusResponseSchema 
+    ? { [K in keyof T]: InferZodType<T[K]> }[keyof T]
+    : never;
+
 // Cookie interface
 interface Cookie {
   name: string;
@@ -35,10 +47,13 @@ interface RouteConfig {
   body?: z.ZodSchema<any>;
   headers?: z.ZodSchema<any>;
   cookies?: z.ZodSchema<any>;
-  response?: z.ZodSchema<any>;
+  response?: ResponseConfig;
   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>;
@@ -53,11 +68,29 @@ export type Context<TConfig extends RouteConfig = {}> = {
     headers?: Record<string, string>;
     cookies?: Cookie[];
   };
+  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
-type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<any> | any;
+// Handler function type with proper response typing
+type Handler<TConfig extends RouteConfig = {}, EC = {}> = (ctx: Context<TConfig> & EC) => Promise<InferResponseType<TConfig['response']>> | InferResponseType<TConfig['response']>;
 
 // Route definition
 interface Route {
@@ -395,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;
   }
 
@@ -433,6 +466,38 @@ export default class BXO {
     return schema.parse(data);
   }
 
+  // Validate response against response config (supports both simple and status-based schemas)
+  private validateResponse(responseConfig: ResponseConfig | undefined, data: any, status: number = 200): any {
+    if (!responseConfig) return data;
+    
+    // If it's a simple schema (not status-based)
+    if ('parse' in responseConfig && typeof responseConfig.parse === 'function') {
+      return responseConfig.parse(data);
+    }
+    
+    // If it's a status-based schema
+    if (typeof responseConfig === 'object' && !('parse' in responseConfig)) {
+      const statusSchema = responseConfig[status];
+      if (statusSchema) {
+        return statusSchema.parse(data);
+      }
+      
+      // If no specific status schema found, try to find a fallback
+      // Common fallback statuses: 200, 201, 400, 500
+      const fallbackStatuses = [200, 201, 400, 500];
+      for (const fallbackStatus of fallbackStatuses) {
+        if (responseConfig[fallbackStatus]) {
+          return responseConfig[fallbackStatus].parse(data);
+        }
+      }
+      
+      // If no schema found for the status, return data as-is
+      return data;
+    }
+    
+    return data;
+  }
+
   // Main request handler
   private async handleRequest(request: Request, server?: any): Promise<Response | undefined> {
     const url = new URL(request.url);
@@ -514,7 +579,11 @@ export default class BXO {
         cookies: validatedCookies,
         path: pathname,
         request,
-        set: {}
+        set: {},
+        status: ((code: number, data?: any) => {
+          ctx.set.status = code;
+          return data;
+        }) as any
       };
     } catch (validationError) {
       // Validation failed - return error response
@@ -575,7 +644,8 @@ export default class BXO {
       if (route.config?.response && !(response instanceof Response)) {
         try {
           console.log('response', response);
-          response = this.validateData(route.config.response, response);
+          const status = ctx.set.status || 200;
+          response = this.validateResponse(route.config.response, response, status);
         } catch (validationError) {
           // Response validation failed
           

package/package.json

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