bxo 0.0.2 → 0.0.4

package/index.ts

@@ -30,16 +30,6 @@ export type Context<TConfig extends RouteConfig = {}> = {
 // Handler function type
 type Handler<TConfig extends RouteConfig = {}> = (ctx: Context<TConfig>) => Promise<any> | any;
 
-// Plugin interface (also exported from plugins/index.ts)
-interface Plugin {
-  name?: string;
-  onRequest?: (ctx: Context) => Promise<void> | void;
-  onResponse?: (ctx: Context, response: any) => Promise<any> | any;
-  onError?: (ctx: Context, error: Error) => Promise<any> | any;
-}
-
-
-
 // Route definition
 interface Route {
   method: string;
@@ -63,14 +53,14 @@ interface LifecycleHooks {
 
 export default class BXO {
   private routes: Route[] = [];
-  private plugins: Plugin[] = [];
+  private plugins: BXO[] = [];
   private hooks: LifecycleHooks = {};
   private server?: any;
   private isRunning: boolean = false;
   private hotReloadEnabled: boolean = false;
   private watchedFiles: Set<string> = new Set();
 
-  constructor() {}
+  constructor() { }
 
   // Lifecycle hook methods
   onBeforeStart(handler: () => Promise<void> | void): this {
@@ -118,9 +108,9 @@ export default class BXO {
     return this;
   }
 
-  // Plugin system
-  use(plugin: Plugin): this {
-    this.plugins.push(plugin);
+  // Plugin system - now accepts other BXO instances
+  use(bxoInstance: BXO): this {
+    this.plugins.push(bxoInstance);
     return this;
   }
 
@@ -326,10 +316,10 @@ export default class BXO {
         await this.hooks.onRequest(ctx);
       }
 
-      // Run plugin onRequest hooks
-      for (const plugin of this.plugins) {
-        if (plugin.onRequest) {
-          await plugin.onRequest(ctx);
+      // Run BXO instance onRequest hooks
+      for (const bxoInstance of this.plugins) {
+        if (bxoInstance.hooks.onRequest) {
+          await bxoInstance.hooks.onRequest(ctx);
         }
       }
 
@@ -341,10 +331,10 @@ export default class BXO {
         response = await this.hooks.onResponse(ctx, response) || response;
       }
 
-      // Run plugin onResponse hooks
-      for (const plugin of this.plugins) {
-        if (plugin.onResponse) {
-          response = await plugin.onResponse(ctx, response) || response;
+      // Run BXO instance onResponse hooks
+      for (const bxoInstance of this.plugins) {
+        if (bxoInstance.hooks.onResponse) {
+          response = await bxoInstance.hooks.onResponse(ctx, response) || response;
         }
       }
 
@@ -378,9 +368,9 @@ export default class BXO {
         errorResponse = await this.hooks.onError(ctx, error as Error);
       }
 
-      for (const plugin of this.plugins) {
-        if (plugin.onError) {
-          errorResponse = await plugin.onError(ctx, error as Error) || errorResponse;
+      for (const bxoInstance of this.plugins) {
+        if (bxoInstance.hooks.onError) {
+          errorResponse = await bxoInstance.hooks.onError(ctx, error as Error) || errorResponse;
         }
       }
 
@@ -414,7 +404,7 @@ export default class BXO {
     if (!this.hotReloadEnabled) return;
 
     const fs = require('fs');
-    
+
     for (const watchPath of this.watchedFiles) {
       try {
         fs.watch(watchPath, { recursive: true }, async (eventType: string, filename: string) => {
@@ -516,19 +506,19 @@ export default class BXO {
       }
 
       console.log('🔄 Restarting BXO server...');
-      
+
       await this.stop();
-      
+
       // Small delay to ensure cleanup
       await new Promise(resolve => setTimeout(resolve, 100));
-      
+
       await this.start(port, hostname);
 
       // After restart hook
       if (this.hooks.onAfterRestart) {
         await this.hooks.onAfterRestart();
       }
-      
+
     } catch (error) {
       console.error('❌ Error restarting server:', error);
       throw error;
@@ -554,10 +544,12 @@ export default class BXO {
   }
 }
 
-// Export Zod for convenience
-export { z };
+const error = (error: Error, status: number = 500) => {
+  return new Response(JSON.stringify({ error: error.message }), { status });
+}
 
-export type { Plugin } from './plugins';
+// Export Zod for convenience
+export { z, error };
 
 // Export types for external use
 export type { RouteConfig };

package/package.json

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

package/plugins/auth.ts

@@ -1,3 +1,5 @@
+import BXO from '../index';
+
 interface AuthOptions {
   type: 'jwt' | 'bearer' | 'apikey';
   secret?: string;
@@ -6,7 +8,7 @@ interface AuthOptions {
   exclude?: string[];
 }
 
-export function auth(options: AuthOptions) {
+export function auth(options: AuthOptions): BXO {
   const {
     type,
     secret,
@@ -15,84 +17,85 @@ export function auth(options: AuthOptions) {
     exclude = []
   } = options;
 
-  return {
-    name: 'auth',
-    onRequest: async (ctx: any) => {
-      const url = new URL(ctx.request.url);
-      const pathname = url.pathname;
-      
-      // Skip auth for excluded paths
-      if (exclude.some(path => {
-        if (path.includes('*')) {
-          const regex = new RegExp(path.replace(/\*/g, '.*'));
-          return regex.test(pathname);
-        }
-        return pathname === path || pathname.startsWith(path);
-      })) {
-        return;
+  const authInstance = new BXO();
+
+  authInstance.onRequest(async (ctx: any) => {
+    const url = new URL(ctx.request.url);
+    const pathname = url.pathname;
+    
+    // Skip auth for excluded paths
+    if (exclude.some(path => {
+      if (path.includes('*')) {
+        const regex = new RegExp(path.replace(/\*/g, '.*'));
+        return regex.test(pathname);
       }
+      return pathname === path || pathname.startsWith(path);
+    })) {
+      return;
+    }
 
-      const authHeader = ctx.request.headers.get(header.toLowerCase());
-      
-      if (!authHeader) {
-        throw new Response(JSON.stringify({ error: 'Authorization header required' }), {
+    const authHeader = ctx.request.headers.get(header.toLowerCase());
+    
+    if (!authHeader) {
+      throw new Response(JSON.stringify({ error: 'Authorization header required' }), {
+        status: 401,
+        headers: { 'Content-Type': 'application/json' }
+      });
+    }
+
+    let token: string;
+    
+    if (type === 'jwt' || type === 'bearer') {
+      if (!authHeader.startsWith('Bearer ')) {
+        throw new Response(JSON.stringify({ error: 'Invalid authorization format. Use Bearer <token>' }), {
           status: 401,
           headers: { 'Content-Type': 'application/json' }
         });
       }
+      token = authHeader.slice(7);
+    } else if (type === 'apikey') {
+      token = authHeader;
+    } else {
+      token = authHeader;
+    }
 
-      let token: string;
+    try {
+      let user: any;
       
-      if (type === 'jwt' || type === 'bearer') {
-        if (!authHeader.startsWith('Bearer ')) {
-          throw new Response(JSON.stringify({ error: 'Invalid authorization format. Use Bearer <token>' }), {
-            status: 401,
-            headers: { 'Content-Type': 'application/json' }
-          });
+      if (verify) {
+        user = await verify(token, ctx);
+      } else if (type === 'jwt' && secret) {
+        // Simple JWT verification (in production, use a proper JWT library)
+        const [headerB64, payloadB64, signature] = token.split('.');
+        if (!headerB64 || !payloadB64 || !signature) {
+          throw new Error('Invalid JWT format');
         }
-        token = authHeader.slice(7);
-      } else if (type === 'apikey') {
-        token = authHeader;
-      } else {
-        token = authHeader;
-      }
-
-      try {
-        let user: any;
         
-        if (verify) {
-          user = await verify(token, ctx);
-        } else if (type === 'jwt' && secret) {
-          // Simple JWT verification (in production, use a proper JWT library)
-          const [headerB64, payloadB64, signature] = token.split('.');
-          if (!headerB64 || !payloadB64 || !signature) {
-            throw new Error('Invalid JWT format');
-          }
-          
-          const payload = JSON.parse(atob(payloadB64));
-          
-          // Check expiration
-          if (payload.exp && Date.now() >= payload.exp * 1000) {
-            throw new Error('Token expired');
-          }
-          
-          user = payload;
-        } else {
-          user = { token };
+        const payload = JSON.parse(atob(payloadB64));
+        
+        // Check expiration
+        if (payload.exp && Date.now() >= payload.exp * 1000) {
+          throw new Error('Token expired');
         }
-
-        // Attach user to context
-        ctx.user = user;
         
-      } catch (error) {
-        const message = error instanceof Error ? error.message : 'Invalid token';
-        throw new Response(JSON.stringify({ error: message }), {
-          status: 401,
-          headers: { 'Content-Type': 'application/json' }
-        });
+        user = payload;
+      } else {
+        user = { token };
       }
+
+      // Attach user to context
+      ctx.user = user;
+      
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Invalid token';
+      throw new Response(JSON.stringify({ error: message }), {
+        status: 401,
+        headers: { 'Content-Type': 'application/json' }
+      });
     }
-  };
+  });
+
+  return authInstance;
 }
 
 // Helper function for creating JWT tokens (simple implementation)

package/plugins/cors.ts

@@ -1,3 +1,5 @@
+import BXO from '../index';
+
 interface CORSOptions {
   origin?: string | string[] | boolean;
   methods?: string[];
@@ -6,7 +8,7 @@ interface CORSOptions {
   maxAge?: number;
 }
 
-export function cors(options: CORSOptions = {}) {
+export function cors(options: CORSOptions = {}): BXO {
   const {
     origin = '*',
     methods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS'],
@@ -15,46 +17,14 @@ export function cors(options: CORSOptions = {}) {
     maxAge = 86400
   } = options;
 
-  return {
-    name: 'cors',
-    onRequest: async (ctx: any) => {
-      // Handle preflight OPTIONS request
-      if (ctx.request.method === 'OPTIONS') {
-        const headers: Record<string, string> = {};
-
-        // Handle origin
-        if (typeof origin === 'boolean') {
-          if (origin) {
-            headers['Access-Control-Allow-Origin'] = ctx.request.headers.get('origin') || '*';
-          }
-        } else if (typeof origin === 'string') {
-          headers['Access-Control-Allow-Origin'] = origin;
-        } else if (Array.isArray(origin)) {
-          const requestOrigin = ctx.request.headers.get('origin');
-          if (requestOrigin && origin.includes(requestOrigin)) {
-            headers['Access-Control-Allow-Origin'] = requestOrigin;
-          }
-        }
-
-        headers['Access-Control-Allow-Methods'] = methods.join(', ');
-        headers['Access-Control-Allow-Headers'] = allowedHeaders.join(', ');
-        
-        if (credentials) {
-          headers['Access-Control-Allow-Credentials'] = 'true';
-        }
-        
-        headers['Access-Control-Max-Age'] = maxAge.toString();
+  const corsInstance = new BXO();
 
-        ctx.set.status = 204;
-        ctx.set.headers = { ...ctx.set.headers, ...headers };
-        
-        throw new Response(null, { status: 204, headers });
-      }
-    },
-    onResponse: async (ctx: any, response: any) => {
+  corsInstance.onRequest(async (ctx: any) => {
+    // Handle preflight OPTIONS request
+    if (ctx.request.method === 'OPTIONS') {
       const headers: Record<string, string> = {};
 
-      // Handle origin for actual requests
+      // Handle origin
       if (typeof origin === 'boolean') {
         if (origin) {
           headers['Access-Control-Allow-Origin'] = ctx.request.headers.get('origin') || '*';
@@ -68,12 +38,46 @@ export function cors(options: CORSOptions = {}) {
         }
       }
 
+      headers['Access-Control-Allow-Methods'] = methods.join(', ');
+      headers['Access-Control-Allow-Headers'] = allowedHeaders.join(', ');
+      
       if (credentials) {
         headers['Access-Control-Allow-Credentials'] = 'true';
       }
+      
+      headers['Access-Control-Max-Age'] = maxAge.toString();
 
+      ctx.set.status = 204;
       ctx.set.headers = { ...ctx.set.headers, ...headers };
-      return response;
+      
+      throw new Response(null, { status: 204, headers });
     }
-  };
+  });
+
+  corsInstance.onResponse(async (ctx: any, response: any) => {
+    const headers: Record<string, string> = {};
+
+    // Handle origin for actual requests
+    if (typeof origin === 'boolean') {
+      if (origin) {
+        headers['Access-Control-Allow-Origin'] = ctx.request.headers.get('origin') || '*';
+      }
+    } else if (typeof origin === 'string') {
+      headers['Access-Control-Allow-Origin'] = origin;
+    } else if (Array.isArray(origin)) {
+      const requestOrigin = ctx.request.headers.get('origin');
+      if (requestOrigin && origin.includes(requestOrigin)) {
+        headers['Access-Control-Allow-Origin'] = requestOrigin;
+      }
+    }
+
+    if (credentials) {
+      headers['Access-Control-Allow-Credentials'] = 'true';
+    }
+
+    ctx.set.headers = { ...ctx.set.headers, ...headers };
+    return response;
+  });
+
+  return corsInstance;
 } 

package/plugins/index.ts

@@ -4,10 +4,8 @@ export { logger } from './logger';
 export { auth, createJWT } from './auth';
 export { rateLimit } from './ratelimit';
 
-// Plugin types for convenience
-export interface Plugin {
-  name?: string;
-  onRequest?: (ctx: any) => Promise<void> | void;
-  onResponse?: (ctx: any, response: any) => Promise<any> | any;
-  onError?: (ctx: any, error: Error) => Promise<any> | any;
-}
+// Import BXO for plugin typing
+import BXO from '../index';
+
+// Plugin functions now return BXO instances
+export type PluginFactory<T = any> = (options?: T) => BXO;

package/plugins/logger.ts

@@ -1,104 +1,109 @@
+import BXO from '../index';
+
 interface LoggerOptions {
   format?: 'simple' | 'detailed' | 'json';
   includeBody?: boolean;
   includeHeaders?: boolean;
 }
 
-export function logger(options: LoggerOptions = {}) {
+export function logger(options: LoggerOptions = {}): BXO {
   const {
     format = 'simple',
     includeBody = false,
     includeHeaders = false
   } = options;
 
-  return {
-    name: 'logger',
-    onRequest: async (ctx: any) => {
-      ctx._startTime = Date.now();
+  const loggerInstance = new BXO();
+
+  loggerInstance.onRequest(async (ctx: any) => {
+    ctx._startTime = Date.now();
+    
+    if (format === 'json') {
+      const logData: any = {
+        timestamp: new Date().toISOString(),
+        method: ctx.request.method,
+        url: ctx.request.url,
+        type: 'request'
+      };
+      
+      if (includeHeaders) {
+        logData.headers = Object.fromEntries(ctx.request.headers.entries());
+      }
       
-      if (format === 'json') {
-        const logData: any = {
-          timestamp: new Date().toISOString(),
-          method: ctx.request.method,
-          url: ctx.request.url,
-          type: 'request'
-        };
-        
-        if (includeHeaders) {
-          logData.headers = Object.fromEntries(ctx.request.headers.entries());
-        }
-        
-        if (includeBody && ctx.body) {
-          logData.body = ctx.body;
-        }
-        
-        console.log(JSON.stringify(logData));
-      } else if (format === 'detailed') {
-        console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
-        if (includeHeaders) {
-          console.log('  Headers:', Object.fromEntries(ctx.request.headers.entries()));
-        }
-        if (includeBody && ctx.body) {
-          console.log('  Body:', ctx.body);
-        }
-      } else {
-        console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
+      if (includeBody && ctx.body) {
+        logData.body = ctx.body;
+      }
+      
+      console.log(JSON.stringify(logData));
+    } else if (format === 'detailed') {
+      console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
+      if (includeHeaders) {
+        console.log('  Headers:', Object.fromEntries(ctx.request.headers.entries()));
+      }
+      if (includeBody && ctx.body) {
+        console.log('  Body:', ctx.body);
       }
-    },
-    onResponse: async (ctx: any, response: any) => {
-      const duration = Date.now() - (ctx._startTime || 0);
-      const status = ctx.set.status || 200;
+    } else {
+      console.log(`→ ${ctx.request.method} ${ctx.request.url}`);
+    }
+  });
+
+  loggerInstance.onResponse(async (ctx: any, response: any) => {
+    const duration = Date.now() - (ctx._startTime || 0);
+    const status = ctx.set.status || 200;
+    
+    if (format === 'json') {
+      const logData: any = {
+        timestamp: new Date().toISOString(),
+        method: ctx.request.method,
+        url: ctx.request.url,
+        status,
+        duration: `${duration}ms`,
+        type: 'response'
+      };
       
-      if (format === 'json') {
-        const logData: any = {
-          timestamp: new Date().toISOString(),
-          method: ctx.request.method,
-          url: ctx.request.url,
-          status,
-          duration: `${duration}ms`,
-          type: 'response'
-        };
-        
-        if (includeHeaders && ctx.set.headers) {
-          logData.responseHeaders = ctx.set.headers;
-        }
-        
-        if (includeBody && response) {
-          logData.response = response;
-        }
-        
-        console.log(JSON.stringify(logData));
-      } else if (format === 'detailed') {
-        console.log(`← ${ctx.request.method} ${ctx.request.url} ${status} ${duration}ms`);
-        if (includeHeaders && ctx.set.headers) {
-          console.log('  Response Headers:', ctx.set.headers);
-        }
-        if (includeBody && response) {
-          console.log('  Response:', response);
-        }
-      } else {
-        const statusColor = status >= 400 ? '\x1b[31m' : status >= 300 ? '\x1b[33m' : '\x1b[32m';
-        const resetColor = '\x1b[0m';
-        console.log(`← ${ctx.request.method} ${ctx.request.url} ${statusColor}${status}${resetColor} ${duration}ms`);
+      if (includeHeaders && ctx.set.headers) {
+        logData.responseHeaders = ctx.set.headers;
       }
       
-      return response;
-    },
-    onError: async (ctx: any, error: Error) => {
-      const duration = Date.now() - (ctx._startTime || 0);
+      if (includeBody && response) {
+        logData.response = response;
+      }
       
-      if (format === 'json') {
-        console.log(JSON.stringify({
-          timestamp: new Date().toISOString(),
-          method: ctx.request.method,
-          url: ctx.request.url,
-          error: error.message,
-          duration: `${duration}ms`,
-          type: 'error'
-        }));
-      } else {
-        console.log(`✗ ${ctx.request.method} ${ctx.request.url} \x1b[31mERROR\x1b[0m ${duration}ms: ${error.message}`);
+      console.log(JSON.stringify(logData));
+    } else if (format === 'detailed') {
+      console.log(`← ${ctx.request.method} ${ctx.request.url} ${status} ${duration}ms`);
+      if (includeHeaders && ctx.set.headers) {
+        console.log('  Response Headers:', ctx.set.headers);
+      }
+      if (includeBody && response) {
+        console.log('  Response:', response);
       }
+    } else {
+      const statusColor = status >= 400 ? '\x1b[31m' : status >= 300 ? '\x1b[33m' : '\x1b[32m';
+      const resetColor = '\x1b[0m';
+      console.log(`← ${ctx.request.method} ${ctx.request.url} ${statusColor}${status}${resetColor} ${duration}ms`);
     }
-  };
+    
+    return response;
+  });
+
+  loggerInstance.onError(async (ctx: any, error: Error) => {
+    const duration = Date.now() - (ctx._startTime || 0);
+    
+    if (format === 'json') {
+      console.log(JSON.stringify({
+        timestamp: new Date().toISOString(),
+        method: ctx.request.method,
+        url: ctx.request.url,
+        error: error.message,
+        duration: `${duration}ms`,
+        type: 'error'
+      }));
+    } else {
+      console.log(`✗ ${ctx.request.method} ${ctx.request.url} \x1b[31mERROR\x1b[0m ${duration}ms: ${error.message}`);
+    }
+  });
+
+  return loggerInstance;
 } 

package/plugins/ratelimit.ts

@@ -1,3 +1,5 @@
+import BXO from '../index';
+
 interface RateLimitOptions {
   max: number;
   window: number; // in seconds
@@ -50,7 +52,7 @@ class RateLimitStore {
   }
 }
 
-export function rateLimit(options: RateLimitOptions) {
+export function rateLimit(options: RateLimitOptions): BXO {
   const {
     max,
     window,
@@ -72,65 +74,67 @@ export function rateLimit(options: RateLimitOptions) {
   // Cleanup expired entries every 5 minutes
   setInterval(() => store.cleanup(), 5 * 60 * 1000);
 
-  return {
-    name: 'rateLimit',
-    onRequest: async (ctx: any) => {
-      const url = new URL(ctx.request.url);
-      const pathname = url.pathname;
-      
-      // Skip rate limiting for excluded paths
-      if (exclude.some(path => {
-        if (path.includes('*')) {
-          const regex = new RegExp(path.replace(/\*/g, '.*'));
-          return regex.test(pathname);
-        }
-        return pathname === path || pathname.startsWith(path);
-      })) {
-        return;
-      }
+  const rateLimitInstance = new BXO();
 
-      const key = keyGenerator(ctx);
-      const entry = store.increment(key, window);
-      
-      if (entry.count > max) {
-        const resetTime = Math.ceil(entry.resetTime / 1000);
-        throw new Response(JSON.stringify({ 
-          error: message,
-          retryAfter: resetTime - Math.floor(Date.now() / 1000)
-        }), {
-          status: statusCode,
-          headers: { 
-            'Content-Type': 'application/json',
-            'X-RateLimit-Limit': max.toString(),
-            'X-RateLimit-Remaining': '0',
-            'X-RateLimit-Reset': resetTime.toString(),
-            'Retry-After': (resetTime - Math.floor(Date.now() / 1000)).toString()
-          }
-        });
+  rateLimitInstance.onRequest(async (ctx: any) => {
+    const url = new URL(ctx.request.url);
+    const pathname = url.pathname;
+    
+    // Skip rate limiting for excluded paths
+    if (exclude.some(path => {
+      if (path.includes('*')) {
+        const regex = new RegExp(path.replace(/\*/g, '.*'));
+        return regex.test(pathname);
       }
-      
-      // Add rate limit headers
-      ctx.set.headers = {
-        ...ctx.set.headers,
-        'X-RateLimit-Limit': max.toString(),
-        'X-RateLimit-Remaining': Math.max(0, max - entry.count).toString(),
-        'X-RateLimit-Reset': Math.ceil(entry.resetTime / 1000).toString()
-      };
-    },
-    onResponse: async (ctx: any, response: any) => {
-      const status = ctx.set.status || 200;
-      const key = keyGenerator(ctx);
-      
-      // Optionally skip counting successful or failed requests
-      if ((skipSuccessful && status < 400) || (skipFailed && status >= 400)) {
-        // Decrement the counter since we don't want to count this request
-        const entry = store.get(key);
-        if (entry && entry.count > 0) {
-          store.set(key, entry.count - 1, entry.resetTime);
+      return pathname === path || pathname.startsWith(path);
+    })) {
+      return;
+    }
+
+    const key = keyGenerator(ctx);
+    const entry = store.increment(key, window);
+    
+    if (entry.count > max) {
+      const resetTime = Math.ceil(entry.resetTime / 1000);
+      throw new Response(JSON.stringify({ 
+        error: message,
+        retryAfter: resetTime - Math.floor(Date.now() / 1000)
+      }), {
+        status: statusCode,
+        headers: { 
+          'Content-Type': 'application/json',
+          'X-RateLimit-Limit': max.toString(),
+          'X-RateLimit-Remaining': '0',
+          'X-RateLimit-Reset': resetTime.toString(),
+          'Retry-After': (resetTime - Math.floor(Date.now() / 1000)).toString()
         }
+      });
+    }
+    
+    // Add rate limit headers
+    ctx.set.headers = {
+      ...ctx.set.headers,
+      'X-RateLimit-Limit': max.toString(),
+      'X-RateLimit-Remaining': Math.max(0, max - entry.count).toString(),
+      'X-RateLimit-Reset': Math.ceil(entry.resetTime / 1000).toString()
+    };
+  });
+
+  rateLimitInstance.onResponse(async (ctx: any, response: any) => {
+    const status = ctx.set.status || 200;
+    const key = keyGenerator(ctx);
+    
+    // Optionally skip counting successful or failed requests
+    if ((skipSuccessful && status < 400) || (skipFailed && status >= 400)) {
+      // Decrement the counter since we don't want to count this request
+      const entry = store.get(key);
+      if (entry && entry.count > 0) {
+        store.set(key, entry.count - 1, entry.resetTime);
       }
-      
-      return response;
     }
-  };
+    
+    return response;
+  });
+
+  return rateLimitInstance;
 }