bxo 0.0.5-dev.43 → 0.0.5-dev.44

package/package.json

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

package/plugins/example.ts

@@ -0,0 +1,173 @@
+import type { Plugin } from '../index';
+
+// Example 1: Simple logging plugin
+export function logger(): Plugin {
+  return {
+    name: 'logger',
+    onRequest: async (ctx) => {
+      console.log(`[${new Date().toISOString()}] ${ctx.request.method} ${ctx.path}`);
+    },
+    onResponse: async (ctx, response) => {
+      if (response instanceof Response) {
+        console.log(`[${new Date().toISOString()}] ${ctx.request.method} ${ctx.path} - ${response.status}`);
+      }
+      return response;
+    },
+    onError: async (ctx, error) => {
+      console.error(`[${new Date().toISOString()}] Error in ${ctx.request.method} ${ctx.path}:`, error);
+    }
+  };
+}
+
+// Example 2: Authentication plugin
+export function auth(secret: string): Plugin {
+  return {
+    name: 'auth',
+    onRequest: async (ctx) => {
+      const token = ctx.headers.authorization?.replace('Bearer ', '');
+      
+      if (!token) {
+        throw new Response(JSON.stringify({ error: 'No token provided' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json' }
+        });
+      }
+      
+      // Simple token validation (replace with your actual logic)
+      if (token !== secret) {
+        throw new Response(JSON.stringify({ error: 'Invalid token' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json' }
+        });
+      }
+      
+      // Add user info to context
+      (ctx as any).user = { id: 'user-123', token };
+    }
+  };
+}
+
+// Example 3: Request timing plugin
+export function timing(): Plugin {
+  return {
+    name: 'timing',
+    onRequest: async (ctx) => {
+      (ctx as any).startTime = Date.now();
+    },
+    onResponse: async (ctx, response) => {
+      const startTime = (ctx as any).startTime;
+      if (startTime) {
+        const duration = Date.now() - startTime;
+        console.log(`Request to ${ctx.path} took ${duration}ms`);
+        
+        // Add timing header to response
+        if (response instanceof Response) {
+          const newResponse = new Response(response.body, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: new Headers(response.headers)
+          });
+          newResponse.headers.set('X-Response-Time', `${duration}ms`);
+          return newResponse;
+        }
+      }
+      return response;
+    }
+  };
+}
+
+// Example 4: Request ID plugin
+export function requestId(): Plugin {
+  return {
+    name: 'requestId',
+    onRequest: async (ctx) => {
+      const requestId = crypto.randomUUID();
+      (ctx as any).requestId = requestId;
+      
+      // Add request ID to response headers
+      ctx.set.headers = {
+        ...ctx.set.headers,
+        'X-Request-ID': requestId
+      };
+    }
+  };
+}
+
+// Example 5: Conditional plugin (only applies to certain paths)
+export function conditionalAuth(secret: string, paths: string[]): Plugin {
+  return {
+    name: 'conditionalAuth',
+    onRequest: async (ctx) => {
+      // Only apply auth to specified paths
+      if (!paths.some(path => ctx.path.startsWith(path))) {
+        return; // Skip authentication for this path
+      }
+      
+      const token = ctx.headers.authorization?.replace('Bearer ', '');
+      
+      if (!token || token !== secret) {
+        throw new Response(JSON.stringify({ error: 'Authentication required' }), {
+          status: 401,
+          headers: { 'Content-Type': 'application/json' }
+        });
+      }
+    }
+  };
+}
+
+// Example 6: Response transformation plugin
+export function responseTransformer(): Plugin {
+  return {
+    name: 'responseTransformer',
+    onResponse: async (ctx, response) => {
+      // Only transform JSON responses
+      if (response instanceof Response) {
+        const contentType = response.headers.get('content-type');
+        if (contentType?.includes('application/json')) {
+          try {
+            const data = await response.json();
+            
+            // Transform the response data
+            const transformed = {
+              success: true,
+              data,
+              timestamp: new Date().toISOString(),
+              path: ctx.path
+            };
+            
+            return new Response(JSON.stringify(transformed), {
+              status: response.status,
+              headers: response.headers
+            });
+          } catch (error) {
+            // If response is not JSON, return as-is
+            return response;
+          }
+        }
+      }
+      
+      return response;
+    }
+  };
+}
+
+// Example 7: Error handling plugin
+export function errorHandler(): Plugin {
+  return {
+    name: 'errorHandler',
+    onError: async (ctx, error) => {
+      console.error(`Error in ${ctx.request.method} ${ctx.path}:`, error);
+      
+      // Return a standardized error response
+      return new Response(JSON.stringify({
+        error: 'Internal Server Error',
+        message: error.message,
+        timestamp: new Date().toISOString(),
+        path: ctx.path
+      }), {
+        status: 500,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+  };
+}