@catbee/utils 0.0.8-rc.0 → 0.0.8-rc.1

package/build/esm/utils/decorators.utils.js

@@ -21,6 +21,17 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -94,8 +105,11 @@ var __values = (this && this.__values) || function(o) {
     throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
 };
 import 'reflect-metadata';
+import { getLogger } from './logger.utils';
+import { createFinalErrorResponse } from './response.utils';
 import { HttpStatusCodes } from './http-status-codes';
-import { ForbiddenException } from './exception.utils';
+import { rateLimit } from 'express-rate-limit';
+import { TTLCache } from './cache.utils';
 // Metadata keys
 var ROUTES_KEY = Symbol('routes');
 var MIDDLEWARE_KEY = Symbol('middlewares');
@@ -106,6 +120,69 @@ var BEFORE_KEY = Symbol('before');
 var AFTER_KEY = Symbol('after');
 var ROLES_KEY = Symbol('roles');
 var REDIRECT_KEY = Symbol('redirect');
+var CACHE_KEY = Symbol('cache');
+var RATE_LIMIT_KEY = Symbol('rateLimit');
+var CONTENT_TYPE_KEY = Symbol('contentType');
+var VERSION_KEY = Symbol('version');
+var TIMEOUT_KEY = Symbol('timeout');
+var LOG_KEY = Symbol('log');
+/**
+ * RateLimiter cache that uses TTLCache for automatic TTL and LRU handling.
+ */
+var RateLimiterCache = /** @class */ (function () {
+    function RateLimiterCache(maxSize, ttlMs) {
+        if (maxSize === void 0) { maxSize = 100; }
+        if (ttlMs === void 0) { ttlMs = 5 * 60 * 1000; }
+        this.cache = new TTLCache({
+            maxSize: maxSize,
+            ttlMs: ttlMs
+        });
+    }
+    RateLimiterCache.prototype.generateKey = function (options) {
+        return "".concat(options.max, ":").concat(options.windowMs, ":").concat(options.standardHeaders, ":").concat(options.legacyHeaders);
+    };
+    RateLimiterCache.prototype.get = function (options) {
+        var key = this.generateKey(options);
+        var cached = this.cache.get(key);
+        if (cached) {
+            return cached.limiter;
+        }
+        // Create new limiter
+        var limiter = rateLimit(__assign(__assign({}, options), { handler: function (req, res) {
+                var errorResponse = createFinalErrorResponse(req, HttpStatusCodes.TOO_MANY_REQUESTS, 'Too Many Requests');
+                res.status(HttpStatusCodes.TOO_MANY_REQUESTS).json(errorResponse);
+            } }));
+        // Store in cache
+        this.cache.set(key, {
+            limiter: limiter,
+            config: key
+        });
+        return limiter;
+    };
+    RateLimiterCache.prototype.clear = function () {
+        this.cache.clear();
+    };
+    RateLimiterCache.prototype.size = function () {
+        return this.cache.size();
+    };
+    RateLimiterCache.prototype.destroy = function () {
+        this.cache.destroy();
+    };
+    return RateLimiterCache;
+}());
+export { RateLimiterCache };
+// Global cache instance
+var rateLimiterCache = new RateLimiterCache();
+function normalizeHeaderValue(value) {
+    if (typeof value === 'undefined')
+        return undefined;
+    if (typeof value === 'string')
+        return value;
+    if (Array.isArray(value) && value.every(function (item) { return typeof item === 'string'; })) {
+        return value;
+    }
+    return String(value);
+}
 /**
  * Factory function that creates HTTP method decorators.
  *
@@ -372,8 +449,8 @@ export function HttpCode(status) {
 /**
  * Decorator that adds a custom HTTP header to the response.
  *
- * @param name - Header name
- * @param value - Header value
+ * @param header - Header name-value pairs or a single header name and value
+ * @param value - Header value if a single header name is provided
  * @returns Method decorator
  *
  * @example
@@ -384,13 +461,45 @@ export function HttpCode(status) {
  *   // Response will include the Cache-Control header
  *   return { data: '...' };
  * }
- * ```
  */
 export function Header(name, value) {
-    return function (target, propertyKey, _descriptor) {
-        var headers = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
-        headers[name] = value;
-        Reflect.defineMetadata(HEADER_KEY, headers, target, propertyKey);
+    return Headers(name, value);
+}
+/**
+ * Decorator that adds a custom HTTP headers to the response.
+ *
+ * @param headers - Header name-value pairs or a single header name and value
+ * @param value - Header value if a single header name is provided
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/data')
+ * @Headers('Cache-Control', 'max-age=60')
+ * getData() {
+ *   // Response will include the Cache-Control header
+ *   return { data: '...' };
+ * }
+ *
+ * @Get('/data/:id')
+ * @Headers({
+ *   'Cache-Control': 'max-age=60',
+ *   'X-Custom-Header': 'custom-value',
+ *   'Content-Security-Policy': "default-src 'self'"
+ * })
+ * getData() {
+ *   // Response will include all specified headers
+ *   return { data: '...' };
+ * }
+ *
+ * ```
+ */
+export function Headers(headers, value) {
+    return function (target, propertyKey) {
+        var _a;
+        var existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
+        var newHeaders = typeof headers === 'string' ? (_a = {}, _a[headers] = value, _a) : headers;
+        Reflect.defineMetadata(HEADER_KEY, __assign(__assign({}, existing), newHeaders), target, propertyKey);
     };
 }
 /**
@@ -497,6 +606,162 @@ export function Redirect(url, statusCode) {
         return descriptor;
     };
 }
+/**
+ * Decorator that adds caching to a route response.
+ *
+ * @param ttlSeconds - Time to live in seconds for the cache
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/data')
+ * @Cache(300) // Cache for 5 minutes
+ * getData() {
+ *   return { data: 'expensive operation result' };
+ * }
+ * ```
+ */
+export function Cache(ttlSeconds) {
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(CACHE_KEY, { ttlSeconds: ttlSeconds }, target, propertyKey);
+    };
+}
+/**
+ * Decorator that applies rate limiting to a route.
+ * Note: Requires 'express-rate-limit' package to be installed.
+ *
+ * @param limit - Maximum number of requests allowed in the window
+ * @param windowMs - Time window in milliseconds
+ * @returns Method decorator
+ *
+ * Default Options:
+ *  - standardHeaders: true
+ *  - legacyHeaders: false
+ *
+ * @example
+ * ```ts
+ * @Post('/login')
+ * @RateLimit({ max: 5, windowMs: 60000, standardHeaders: true, legacyHeaders: false }) // 5 requests per minute
+ * login(@Body() credentials: LoginDto) {
+ *   return this.authService.login(credentials);
+ * }
+ * ```
+ */
+export function RateLimit(options) {
+    var opts = __assign({ standardHeaders: true, legacyHeaders: false }, options);
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
+    };
+}
+/**
+ * Decorator that sets the content type for the response.
+ *
+ * @param type - MIME type for the response
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/download')
+ * @ContentType('application/pdf')
+ * downloadPdf() {
+ *   return this.fileService.generatePdf();
+ * }
+ * ```
+ */
+export function ContentType(type) {
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(CONTENT_TYPE_KEY, { type: type }, target, propertyKey);
+    };
+}
+/**
+ * Decorator that adds API versioning to a route.
+ *
+ * @param version - Version string for the API endpoint
+ * @param options - Versioning options
+ * @returns Method decorator
+ *
+ * Default Options:
+ *  - addPrefix: true
+ *  - addHeader: true
+ *  - headerName: 'X-API-Version'
+ *
+ * @example
+ * ```ts
+ *
+ * @Get('/users')
+ * @Version('v2')
+ * getUsersV2() {
+ *   return this.userService.findAllV2();
+ * }
+ *
+ * @Get('/users')
+ * @Version('v2', { addPrefix: true, addHeader: true, headerName: 'X-API-Version' })
+ * getUsersV2() {
+ *   // Route becomes /v2/users
+ *   return this.userService.findAllV2();
+ * }
+ * ```
+ */
+export function Version(version, options) {
+    var opts = __assign({ addPrefix: true, addHeader: true, headerName: 'X-API-Version' }, options);
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(VERSION_KEY, { version: version, options: opts }, target, propertyKey);
+    };
+}
+/**
+ * Decorator that sets a timeout for route execution.
+ *
+ * @param ms - Timeout in milliseconds
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/slow-operation')
+ * @Timeout(30000) // 30 second timeout
+ * slowOperation() {
+ *   return this.heavyService.processData();
+ * }
+ * ```
+ */
+export function Timeout(ms) {
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(TIMEOUT_KEY, { ms: ms }, target, propertyKey);
+    };
+}
+/**
+ * Decorator that adds comprehensive logging to a route.
+ *
+ * @param options - Logging configuration options
+ * @returns Method decorator
+ *
+ * Default Options:
+ *  - logEntry: true
+ *  - logExit: true
+ *  - logBody: false
+ *  - logParams: false
+ *  - logResponse: false
+ *
+ * @example
+ * ```ts
+ * @Post('/users')
+ * @Log({
+ *   logEntry: true,
+ *   logExit: true,
+ *   logBody: true,
+ *   logParams: true,
+ *   logResponse: false
+ * })
+ * createUser(@Body() userData: any) {
+ *   return this.userService.create(userData);
+ * }
+ * ```
+ */
+export function Log(options) {
+    return function (target, propertyKey, _descriptor) {
+        var config = __assign({ logEntry: true, logExit: true, logBody: false, logParams: false, logResponse: false }, options);
+        Reflect.defineMetadata(LOG_KEY, config, target, propertyKey);
+    };
+}
 /**
  * Registers all controller classes with the provided router.
  * This function processes all decorators and sets up the Express routes.
@@ -510,61 +775,160 @@ export function registerControllers(router, controllers) {
         var instance = new ControllerClass();
         var basePath = Reflect.getMetadata('basePath', ControllerClass) || '';
         var routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
+        // Get controller-level decorators (fallback values)
+        var controllerRateLimit = Reflect.getMetadata(RATE_LIMIT_KEY, ControllerClass);
+        var controllerCache = Reflect.getMetadata(CACHE_KEY, ControllerClass);
+        var controllerTimeout = Reflect.getMetadata(TIMEOUT_KEY, ControllerClass);
+        var controllerVersion = Reflect.getMetadata(VERSION_KEY, ControllerClass);
+        var controllerRoles = Reflect.getMetadata(ROLES_KEY, ControllerClass);
+        var controllerLogConfig = Reflect.getMetadata(LOG_KEY, ControllerClass);
+        var controllerHeaders = Reflect.getMetadata(HEADER_KEY, ControllerClass) || {};
         routes.forEach(function (_a) {
             var _b;
+            var _c;
             var path = _a.path, method = _a.method, handlerName = _a.handlerName;
             var middlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, handlerName) || [];
             var params = Reflect.getMetadata(PARAMS_KEY, instance, handlerName) || [];
             var httpCode = Reflect.getMetadata(HTTP_CODE_KEY, instance, handlerName);
-            var headers = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
+            // Merge controller-level and method-level headers
+            var methodHeaders = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
+            var headers = __assign(__assign({}, controllerHeaders), methodHeaders);
             var beforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
             var afterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
-            var roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || [];
             var redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
+            var contentType = Reflect.getMetadata(CONTENT_TYPE_KEY, instance, handlerName);
+            // Use method-level decorators if present, otherwise fall back to controller-level
+            var roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerRoles || [];
+            var cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerCache;
+            var rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerRateLimit;
+            var version = Reflect.getMetadata(VERSION_KEY, instance, handlerName) || controllerVersion;
+            var timeout = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerTimeout;
+            var logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerLogConfig;
+            // Create rate limiter for this specific route if needed
+            var rateLimiter = null;
+            if (rateLimitOptions) {
+                try {
+                    rateLimiter = rateLimiterCache.get(rateLimitOptions);
+                }
+                catch (err) {
+                    getLogger().warn({ err: err }, 'express-rate-limit not available, skipping rate limiting for this route');
+                }
+            }
+            var finalPath = path;
+            if ((_c = version === null || version === void 0 ? void 0 : version.options) === null || _c === void 0 ? void 0 : _c.addPrefix) {
+                finalPath = "/".concat(version.version).concat(path);
+            }
             var handler = function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
-                var beforeHooks_1, beforeHooks_1_1, fn, e_1_1, args_1, result, awaited, _a, redirectUrl, redirectStatus, _b, _c, _d, k, v, afterHooks_1, afterHooks_1_1, fn, e_2_1, err_1;
+                var timeoutId, timedOut, logger, logData, errorResponse, beforeHooks_1, beforeHooks_1_1, fn, e_1_1, args_1, result, awaited, _a, redirectUrl, redirectStatus, _b, _c, _d, k, v, normalized, logger, logData, afterHooks_1, afterHooks_1_1, fn, e_2_1, err_1;
                 var e_1, _e, _f, e_3, _g, e_2, _h;
                 var _j, _k, _l, _m;
                 return __generator(this, function (_o) {
                     switch (_o.label) {
                         case 0:
-                            _o.trys.push([0, 20, , 21]);
+                            // Set start time for duration tracking
+                            req['startTime'] = Date.now();
+                            timedOut = false;
+                            _o.label = 1;
+                        case 1:
+                            _o.trys.push([1, 23, , 24]);
+                            // Handle timeout setup
+                            if (timeout) {
+                                timeoutId = setTimeout(function () {
+                                    if (!res.headersSent && !timedOut) {
+                                        timedOut = true;
+                                        var errorResponse = createFinalErrorResponse(req, HttpStatusCodes.REQUEST_TIMEOUT, 'Request timed out');
+                                        res.status(HttpStatusCodes.REQUEST_TIMEOUT).json(errorResponse);
+                                    }
+                                }, timeout.ms);
+                            }
+                            if (timedOut)
+                                return [2 /*return*/];
+                            if (!rateLimiter) return [3 /*break*/, 3];
+                            return [4 /*yield*/, new Promise(function (resolve, reject) {
+                                    rateLimiter(req, res, function (err) {
+                                        if (err)
+                                            reject(err);
+                                        else
+                                            resolve();
+                                    });
+                                })];
+                        case 2:
+                            _o.sent();
+                            _o.label = 3;
+                        case 3:
+                            // Handle content type
+                            if (!res.headersSent && contentType) {
+                                res.setHeader('Content-Type', contentType.type);
+                            }
+                            // Handle versioning header
+                            if (((_j = version === null || version === void 0 ? void 0 : version.options) === null || _j === void 0 ? void 0 : _j.addHeader) && ((_k = version === null || version === void 0 ? void 0 : version.options) === null || _k === void 0 ? void 0 : _k.headerName) && (version === null || version === void 0 ? void 0 : version.version)) {
+                                if (!res.headersSent) {
+                                    res.setHeader(version.options.headerName, version.version);
+                                }
+                            }
+                            // Handle caching
+                            if (cache && !res.headersSent) {
+                                res.setHeader('Cache-Control', "public, max-age=".concat(cache.ttlSeconds));
+                            }
+                            // Handle logging - entry
+                            if (logConfig === null || logConfig === void 0 ? void 0 : logConfig.logEntry) {
+                                logger = getLogger();
+                                logData = {
+                                    method: req.method,
+                                    url: req.originalUrl || req.url,
+                                    userAgent: req.get('User-Agent')
+                                };
+                                if (logConfig.logParams) {
+                                    logData.params = req.params;
+                                    logData.query = req.query;
+                                }
+                                if (logConfig.logBody)
+                                    logData.body = req.body;
+                                logger.info({ entry: logData }, 'Route Entry:');
+                            }
                             // Handle roles-based access control
-                            if (roles.length && !((_k = (_j = req === null || req === void 0 ? void 0 : req.user) === null || _j === void 0 ? void 0 : _j.roles) === null || _k === void 0 ? void 0 : _k.some(function (role) { return roles.includes(role); }))) {
-                                res.status(HttpStatusCodes.FORBIDDEN).json(new ForbiddenException('Forbidden Insufficient Roles'));
+                            if (roles.length && !((_m = (_l = req === null || req === void 0 ? void 0 : req.user) === null || _l === void 0 ? void 0 : _l.roles) === null || _m === void 0 ? void 0 : _m.some(function (role) { return roles.includes(role); }))) {
+                                errorResponse = createFinalErrorResponse(req, HttpStatusCodes.FORBIDDEN, 'Forbidden Insufficient Roles');
+                                res.status(HttpStatusCodes.FORBIDDEN).json(errorResponse);
+                                if (timeoutId) {
+                                    clearTimeout(timeoutId);
+                                }
                                 return [2 /*return*/];
                             }
                             // Process static redirect if configured
                             if (redirect && redirect.url) {
+                                if (timeoutId) {
+                                    clearTimeout(timeoutId);
+                                }
                                 return [2 /*return*/, res.redirect(redirect.statusCode, redirect.url)];
                             }
-                            _o.label = 1;
-                        case 1:
-                            _o.trys.push([1, 6, 7, 8]);
+                            _o.label = 4;
+                        case 4:
+                            _o.trys.push([4, 9, 10, 11]);
                             beforeHooks_1 = __values(beforeHooks), beforeHooks_1_1 = beforeHooks_1.next();
-                            _o.label = 2;
-                        case 2:
-                            if (!!beforeHooks_1_1.done) return [3 /*break*/, 5];
+                            _o.label = 5;
+                        case 5:
+                            if (!!beforeHooks_1_1.done) return [3 /*break*/, 8];
                             fn = beforeHooks_1_1.value;
                             return [4 /*yield*/, fn(req, res)];
-                        case 3:
+                        case 6:
                             _o.sent();
-                            _o.label = 4;
-                        case 4:
+                            _o.label = 7;
+                        case 7:
                             beforeHooks_1_1 = beforeHooks_1.next();
-                            return [3 /*break*/, 2];
-                        case 5: return [3 /*break*/, 8];
-                        case 6:
+                            return [3 /*break*/, 5];
+                        case 8: return [3 /*break*/, 11];
+                        case 9:
                             e_1_1 = _o.sent();
                             e_1 = { error: e_1_1 };
-                            return [3 /*break*/, 8];
-                        case 7:
+                            return [3 /*break*/, 11];
+                        case 10:
                             try {
                                 if (beforeHooks_1_1 && !beforeHooks_1_1.done && (_e = beforeHooks_1.return)) _e.call(beforeHooks_1);
                             }
                             finally { if (e_1) throw e_1.error; }
                             return [7 /*endfinally*/];
-                        case 8:
+                        case 11:
                             args_1 = [];
                             if (params.length) {
                                 params.forEach(function (_a) {
@@ -590,16 +954,22 @@ export function registerControllers(router, controllers) {
                                 });
                             }
                             result = (_f = instance)[handlerName].apply(_f, __spreadArray([], __read(args_1), false));
-                            if (!(result instanceof Promise)) return [3 /*break*/, 10];
+                            if (!(result instanceof Promise)) return [3 /*break*/, 13];
                             return [4 /*yield*/, result];
-                        case 9:
+                        case 12:
                             _a = _o.sent();
-                            return [3 /*break*/, 11];
-                        case 10:
+                            return [3 /*break*/, 14];
+                        case 13:
                             _a = result;
-                            _o.label = 11;
-                        case 11:
+                            _o.label = 14;
+                        case 14:
                             awaited = _a;
+                            // Clear timeout if operation completed
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
+                            if (timedOut)
+                                return [2 /*return*/];
                             // Handle dynamic redirects
                             if (redirect && awaited && typeof awaited === 'object' && 'url' in awaited) {
                                 redirectUrl = awaited.url;
@@ -608,11 +978,14 @@ export function registerControllers(router, controllers) {
                             }
                             if (!res.headersSent && typeof awaited !== 'undefined') {
                                 if (httpCode)
-                                    (_l = res.status) === null || _l === void 0 ? void 0 : _l.call(res, httpCode);
+                                    res.status(httpCode);
                                 try {
                                     for (_b = __values(Object.entries(headers)), _c = _b.next(); !_c.done; _c = _b.next()) {
                                         _d = __read(_c.value, 2), k = _d[0], v = _d[1];
-                                        (_m = res.set) === null || _m === void 0 ? void 0 : _m.call(res, k, v);
+                                        normalized = normalizeHeaderValue(v);
+                                        if (typeof normalized !== 'undefined') {
+                                            res.set(k, normalized);
+                                        }
                                     }
                                 }
                                 catch (e_3_1) { e_3 = { error: e_3_1 }; }
@@ -624,43 +997,61 @@ export function registerControllers(router, controllers) {
                                 }
                                 res.json(awaited);
                             }
-                            _o.label = 12;
-                        case 12:
-                            _o.trys.push([12, 17, 18, 19]);
+                            // Handle logging - exit
+                            if (logConfig === null || logConfig === void 0 ? void 0 : logConfig.logExit) {
+                                logger = getLogger();
+                                logData = {
+                                    method: req.method,
+                                    url: req.originalUrl || req.url,
+                                    statusCode: res.statusCode,
+                                    duration: "".concat(Date.now() - req.startTime, "ms")
+                                };
+                                if (logConfig.logResponse)
+                                    logData.response = awaited;
+                                logger.info({ exit: logData }, 'Route Exit:');
+                            }
+                            _o.label = 15;
+                        case 15:
+                            _o.trys.push([15, 20, 21, 22]);
                             afterHooks_1 = __values(afterHooks), afterHooks_1_1 = afterHooks_1.next();
-                            _o.label = 13;
-                        case 13:
-                            if (!!afterHooks_1_1.done) return [3 /*break*/, 16];
+                            _o.label = 16;
+                        case 16:
+                            if (!!afterHooks_1_1.done) return [3 /*break*/, 19];
                             fn = afterHooks_1_1.value;
                             return [4 /*yield*/, fn(req, res, awaited)];
-                        case 14:
+                        case 17:
                             _o.sent();
-                            _o.label = 15;
-                        case 15:
+                            _o.label = 18;
+                        case 18:
                             afterHooks_1_1 = afterHooks_1.next();
-                            return [3 /*break*/, 13];
-                        case 16: return [3 /*break*/, 19];
-                        case 17:
+                            return [3 /*break*/, 16];
+                        case 19: return [3 /*break*/, 22];
+                        case 20:
                             e_2_1 = _o.sent();
                             e_2 = { error: e_2_1 };
-                            return [3 /*break*/, 19];
-                        case 18:
+                            return [3 /*break*/, 22];
+                        case 21:
                             try {
                                 if (afterHooks_1_1 && !afterHooks_1_1.done && (_h = afterHooks_1.return)) _h.call(afterHooks_1);
                             }
                             finally { if (e_2) throw e_2.error; }
                             return [7 /*endfinally*/];
-                        case 19: return [3 /*break*/, 21];
-                        case 20:
+                        case 22: return [3 /*break*/, 24];
+                        case 23:
                             err_1 = _o.sent();
+                            if (timeoutId) {
+                                clearTimeout(timeoutId);
+                            }
                             next(err_1);
-                            return [3 /*break*/, 21];
-                        case 21: return [2 /*return*/];
+                            return [3 /*break*/, 24];
+                        case 24: return [2 /*return*/];
                     }
                 });
             }); };
-            (_b = router)[method].apply(_b, __spreadArray(__spreadArray([basePath + path], __read(middlewares), false), [handler], false));
+            (_b = router)[method].apply(_b, __spreadArray(__spreadArray([basePath + finalPath], __read(middlewares), false), [handler], false));
         });
     });
 }
+// Export for testing purposes
+export { rateLimiterCache };
 //# sourceMappingURL=decorators.utils.js.map