@kanjijs/throttler 0.2.0-beta.14 → 0.2.0-beta.15

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kanjijs/throttler",
-  "version": "0.2.0-beta.14",
+  "version": "0.2.0-beta.15",
   "type": "module",
   "main": "./src/index.ts",
   "dependencies": {
@@ -8,7 +8,7 @@
     "reflect-metadata": "^0.2.0"
   },
   "peerDependencies": {
-    "@kanjijs/core": "^0.2.0-beta.14"
+    "@kanjijs/core": "^0.2.0-beta.15"
   },
   "scripts": {
     "build": "bun build ./src/index.ts --outdir ./dist --target bun"

package/src/index.ts

@@ -1,6 +1,7 @@
 console.log("Throttler Package Loaded");
+
+export * from "./throttler.decorator";
+export * from "./throttler.guard";
 export * from "./throttler.module";
 export * from "./throttler.service";
-export * from "./throttler.decorator";
 export * from "./throttler.storage";
-export * from "./throttler.guard";

package/src/throttler.decorator.ts

@@ -1,4 +1,4 @@
-import { Use, KanjijsIoC } from "@kanjijs/core";
+import { KanjijsIoC, Use } from "@kanjijs/core";
 import { type Context, type Next } from "hono";
 import { ThrottlerService } from "./throttler.service";
 
@@ -11,17 +11,17 @@ export function Throttle(options: ThrottlerOptions) {
   return Use(async (c: Context, next: Next) => {
     // Resolve singleton
     const throttler = KanjijsIoC.resolve(ThrottlerService) as ThrottlerService | undefined;
-    
+
     if (throttler) {
       // Use specific options from decorator
       const allowed = await throttler.handleRequest(c, options.limit, options.ttl);
       if (!allowed) return; // Blocked (handleRequest sets status/body)
     } else {
-        // Fallback or warning? If module is not imported, throttler service won't exist.
-        // It's safe to just next() or warn.
-        console.warn("@Throttle used but ThrottlerModule not imported/provided.");
+      // Fallback or warning? If module is not imported, throttler service won't exist.
+      // It's safe to just next() or warn.
+      console.warn("@Throttle used but ThrottlerModule not imported/provided.");
     }
-    
+
     await next();
   });
 }

package/src/throttler.guard.ts

@@ -1,12 +1,14 @@
-import { Inject, Injectable, GLOBAL_MIDDLEWARE_TOKEN } from "@kanjijs/core";
-import { type Context, type Handler, type Next } from "hono";
-import { type ThrottlerModuleOptions, THROTTLER_OPTIONS, ThrottlerService } from "./throttler.service";
+import { Inject, Injectable } from "@kanjijs/core";
+import { type Context, type Next } from "hono";
+import { ThrottlerService } from "./throttler.service";
 
 @Injectable()
 export class ThrottlerGuard {
-  constructor(
-    @Inject(ThrottlerService) private throttler: ThrottlerService
-  ) {}
+  private throttler: ThrottlerService;
+
+  constructor(@Inject(ThrottlerService) throttler: ThrottlerService) {
+    this.throttler = throttler;
+  }
 
   // This will be registered as a Global Middleware in KanjijsAdapter if provided
   async handle(c: Context, next: Next) {
@@ -16,8 +18,8 @@ export class ThrottlerGuard {
     const allowed = await this.throttler.handleRequest(c, limit, ttl);
 
     if (!allowed) {
-        // Response is already handled by service (429)
-        return; 
+      // Response is already handled by service (429)
+      return;
     }
 
     await next();

package/src/throttler.module.ts

@@ -1,8 +1,13 @@
-import { Module, GLOBAL_MIDDLEWARE_TOKEN, KanjijsIoC } from "@kanjijs/core";
+import { GLOBAL_MIDDLEWARE_TOKEN, KanjijsIoC, Module } from "@kanjijs/core";
 import type { Context, Next } from "hono";
-import { ThrottlerService, THROTTLER_OPTIONS, type ThrottlerModuleOptions } from "./throttler.service";
+import {
+  THROTTLER_OPTIONS,
+  type ThrottlerModuleOptions,
+  ThrottlerService,
+} from "./throttler.service";
 
 @Module({})
+// biome-ignore lint/complexity/noStaticOnlyClass: ThrottlerModule is a static module container
 export class ThrottlerModule {
   static forRoot(options: ThrottlerModuleOptions) {
     return {
@@ -16,19 +21,19 @@ export class ThrottlerModule {
         {
           provide: GLOBAL_MIDDLEWARE_TOKEN,
           useValue: async (c: Context, next: Next) => {
-             // console.log("Throttler Middleware Executing via Global Token");
-             const throttler = KanjijsIoC.resolve(ThrottlerService) as ThrottlerService | undefined;
-             if (throttler) {
-                 const { limit, ttl } = throttler.getGlobalOptions();
-                 const allowed = await throttler.handleRequest(c, limit, ttl);
-                 if (!allowed) {
-                    c.header("Retry-After", ttl.toString());
-                    return c.text("Too Many Requests", 429);
-                 }
-             }
-             await next();
-          }
-        }
+            // console.log("Throttler Middleware Executing via Global Token");
+            const throttler = KanjijsIoC.resolve(ThrottlerService) as ThrottlerService | undefined;
+            if (throttler) {
+              const { limit, ttl } = throttler.getGlobalOptions();
+              const allowed = await throttler.handleRequest(c, limit, ttl);
+              if (!allowed) {
+                c.header("Retry-After", ttl.toString());
+                return c.text("Too Many Requests", 429);
+              }
+            }
+            await next();
+          },
+        },
       ],
       exports: [ThrottlerService],
     };

package/src/throttler.service.ts

@@ -16,7 +16,7 @@ export class ThrottlerService {
   private defaultLimit: number;
   private defaultTtl: number;
 
-  constructor(@Inject(THROTTLER_OPTIONS) private options: ThrottlerModuleOptions) {
+  constructor(@Inject(THROTTLER_OPTIONS) options: ThrottlerModuleOptions) {
     this.storage = options.storage || new ThrottlerInMemoryStorage();
     this.defaultLimit = options.limit || 10;
     this.defaultTtl = options.ttl || 60;
@@ -29,7 +29,7 @@ export class ThrottlerService {
   async handleRequest(c: Context, limit: number, ttl: number): Promise<boolean> {
     const ip = c.req.header("x-forwarded-for") || "unknown";
     const path = c.req.path;
-    const key = `throttler:${ip}:${path}`; 
+    const key = `throttler:${ip}:${path}`;
 
     const { total, timeToExpire } = await this.storage.increment(key, ttl);