feat: add helper to disable limits for the given request

src/http_limiter.ts

@@ -128,6 +128,13 @@ export class HttpLimiter<KnownStores extends Record<string, LimiterManagerStoreF
     return this
   }
 
+  /**
+   * Returns null to disable rate limiting for the given request
+   */
+  noLimit() {
+    return null
+  }
+
   /**
    * JSON representation of the http limiter
    */

src/limiter_manager.ts

@@ -114,8 +114,11 @@ export class LimiterManager<KnownStores extends Record<string, LimiterManagerSto
    */
   define(
     name: string,
-    builder: (ctx: HttpContext, httpLimiter: HttpLimiter<KnownStores>) => HttpLimiter<KnownStores>
-  ): (ctx: HttpContext) => HttpLimiter<KnownStores> {
+    builder: (
+      ctx: HttpContext,
+      httpLimiter: HttpLimiter<KnownStores>
+    ) => HttpLimiter<any> | null | Promise<HttpLimiter<any>> | Promise<null>
+  ): (ctx: HttpContext) => HttpLimiter<any> | null | Promise<HttpLimiter<any>> | Promise<null> {
     return (ctx: HttpContext) => {
       const limiter = new HttpLimiter(name, ctx, this)
       return builder(ctx, limiter)

tests/throttle_middleware.spec.ts

@@ -60,7 +60,8 @@ test.group('Throttle middleware', () => {
     })
     const ctx = new HttpContextFactory().create()
 
-    await apiLimiter(ctx).throttle()
+    const limiter = await apiLimiter(ctx)
+    await limiter!.throttle()
 
     try {
       await new ThrottleMiddleware().handle(
@@ -78,14 +79,26 @@ test.group('Throttle middleware', () => {
 
   test('do not throttle request when no limiter is used', async ({ assert }) => {
     let nextCalled: boolean = false
+
+    const redis = createRedis(['rlflx:api_1']).connection()
+    const limiterManager = new LimiterManager({
+      default: 'redis',
+      stores: {
+        redis: (options) => new LimiterRedisStore(redis, options),
+      },
+    })
+
+    const apiLimiter = limiterManager.define('api', (_, limiter) => {
+      return limiter.noLimit()
+    })
     const ctx = new HttpContextFactory().create()
 
     await new ThrottleMiddleware().handle(
       ctx,
       () => {
         nextCalled = true
       },
-      () => null
+      apiLimiter
     )
     assert.isTrue(nextCalled)
   })