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

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

@@ -0,0 +1,666 @@
+/*
+ * The MIT License
+ *
+ * Copyright (c) 2025 Catbee Technologies. https://catbee-utils.npm.hprasath.com/license
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+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) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype);
+    return g.next = verb(0), g["throw"] = verb(1), g["return"] = verb(2), typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+var __values = (this && this.__values) || function(o) {
+    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+    if (m) return m.call(o);
+    if (o && typeof o.length === "number") return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+};
+import 'reflect-metadata';
+import { HttpStatusCodes } from './http-status-codes';
+import { ForbiddenException } from './exception.utils';
+// Metadata keys
+var ROUTES_KEY = Symbol('routes');
+var MIDDLEWARE_KEY = Symbol('middlewares');
+var PARAMS_KEY = Symbol('params');
+var HTTP_CODE_KEY = Symbol('httpCode');
+var HEADER_KEY = Symbol('headers');
+var BEFORE_KEY = Symbol('before');
+var AFTER_KEY = Symbol('after');
+var ROLES_KEY = Symbol('roles');
+var REDIRECT_KEY = Symbol('redirect');
+/**
+ * Factory function that creates HTTP method decorators.
+ *
+ * @param method - HTTP method to create decorator for
+ * @returns A method decorator function
+ */
+function createRouteDecorator(method) {
+    return function (path) {
+        return function (target, propertyKey, descriptor) {
+            var routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
+            routes.push({
+                path: path,
+                method: method,
+                handlerName: propertyKey
+            });
+            Reflect.defineMetadata(ROUTES_KEY, routes, target.constructor);
+        };
+    };
+}
+/**
+ * Decorator for GET HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/users')
+ * getUsers() {
+ *   return this.userService.findAll();
+ * }
+ * ```
+ */
+export var Get = createRouteDecorator('get');
+/**
+ * Decorator for POST HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Post('/users')
+ * createUser(@Body() userData: any) {
+ *   return this.userService.create(userData);
+ * }
+ * ```
+ */
+export var Post = createRouteDecorator('post');
+/**
+ * Decorator for PUT HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Put = createRouteDecorator('put');
+/**
+ * Decorator for PATCH HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Patch = createRouteDecorator('patch');
+/**
+ * Decorator for DELETE HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Delete = createRouteDecorator('delete');
+/**
+ * Decorator for OPTIONS HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Options = createRouteDecorator('options');
+/**
+ * Decorator for HEAD HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Head = createRouteDecorator('head');
+/**
+ * Decorator for TRACE HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Trace = createRouteDecorator('trace');
+/**
+ * Decorator for CONNECT HTTP method routes.
+ *
+ * @param path - URL path for the route
+ * @returns Method decorator
+ */
+export var Connect = createRouteDecorator('connect');
+/**
+ * Decorator that marks a class as a controller with a base path.
+ * Used as the entry point for routing configuration.
+ *
+ * @param basePath - Base URL path for all routes in this controller
+ * @returns Class decorator
+ *
+ * @example
+ * ```ts
+ * @Controller('/api/users')
+ * class UserController {
+ *   // Controller methods...
+ * }
+ * ```
+ */
+export function Controller(basePath) {
+    return function (target) {
+        Reflect.defineMetadata('basePath', basePath, target);
+    };
+}
+/**
+ * Decorator that applies middleware to a controller method.
+ * Multiple middlewares can be applied and will execute in order.
+ *
+ * @param middlewares - Express middleware functions to apply
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/protected')
+ * @Use(authMiddleware, loggingMiddleware)
+ * getProtectedResource() {
+ *   // This route is protected by auth middleware
+ * }
+ * ```
+ */
+export function Use() {
+    var middlewares = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        middlewares[_i] = arguments[_i];
+    }
+    return function (target, propertyKey, _descriptor) {
+        var existing = Reflect.getMetadata(MIDDLEWARE_KEY, target, propertyKey) || [];
+        Reflect.defineMetadata(MIDDLEWARE_KEY, __spreadArray(__spreadArray([], __read(existing), false), __read(middlewares), false), target, propertyKey);
+    };
+}
+/**
+ * Factory function that creates parameter decorators.
+ *
+ * @param type - Parameter type to extract from request
+ * @param key - Optional fixed key for extraction
+ * @returns Parameter decorator function
+ */
+function createParamDecorator(type, key) {
+    return function (paramKey) {
+        return function (target, propertyKey, parameterIndex) {
+            var params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+            // Ensure parameters are ordered by index
+            params.push({ index: parameterIndex, type: type, key: paramKey || key });
+            params.sort(function (a, b) { return a.index - b.index; });
+            Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
+        };
+    };
+}
+/**
+ * Decorator that extracts query parameters from request.
+ *
+ * @param paramKey - Optional key to extract specific query parameter
+ * @returns Parameter decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/search')
+ * search(@Query('term') searchTerm: string) {
+ *   // searchTerm will contain the value of req.query.term
+ * }
+ * ```
+ */
+export var Query = createParamDecorator('query');
+/**
+ * Decorator that extracts route parameters from request.
+ *
+ * @param paramKey - Optional key to extract specific route parameter
+ * @returns Parameter decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/users/:id')
+ * getUser(@Param('id') userId: string) {
+ *   // userId will contain the value of req.params.id
+ * }
+ * ```
+ */
+export var Param = createParamDecorator('param');
+/**
+ * Decorator that extracts body or body property from request.
+ *
+ * @param paramKey - Optional key to extract specific body property
+ * @returns Parameter decorator
+ *
+ * @example
+ * ```ts
+ * @Post('/users')
+ * createUser(@Body() userData: any) {
+ *   // userData will contain the entire req.body
+ * }
+ *
+ * @Post('/update')
+ * updateName(@Body('name') name: string) {
+ *   // name will contain the value of req.body.name
+ * }
+ * ```
+ */
+export var Body = createParamDecorator('body');
+/**
+ * Decorator that injects the entire request object.
+ *
+ * @returns Parameter decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/complex')
+ * complex(@Req() req: Request) {
+ *   // Access the full request object
+ *   console.log(req.headers);
+ * }
+ * ```
+ */
+export var Req = createParamDecorator('req');
+/**
+ * Decorator that injects the response object.
+ *
+ * @returns Parameter decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/custom')
+ * custom(@Res() res: Response) {
+ *   // Direct access to response object
+ *   return res.status(201).send('Created');
+ * }
+ * ```
+ */
+export var Res = createParamDecorator('res');
+/**
+ * Decorator that sets a custom HTTP status code for a response.
+ *
+ * @param status - HTTP status code to use
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Post('/users')
+ * @HttpCode(201)
+ * createUser(@Body() userData: any) {
+ *   // Response will have 201 Created status code
+ *   return { id: '123', ...userData };
+ * }
+ * ```
+ */
+export function HttpCode(status) {
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(HTTP_CODE_KEY, status, target, propertyKey);
+    };
+}
+/**
+ * Decorator that adds a custom HTTP header to the response.
+ *
+ * @param name - Header name
+ * @param value - Header value
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/data')
+ * @Header('Cache-Control', 'max-age=60')
+ * getData() {
+ *   // 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);
+    };
+}
+/**
+ * Decorator that registers a function to run before route handler execution.
+ * Useful for pre-processing or logging.
+ *
+ * @param fn - Function to execute before the handler
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/users/:id')
+ * @Before((req, res) => console.log(`Accessing user ${req.params.id}`))
+ * getUser(@Param('id') id: string) {
+ *   // Function will log before this handler runs
+ * }
+ * ```
+ */
+export function Before(fn) {
+    return function (target, propertyKey, _descriptor) {
+        var hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
+        hooks.push(fn);
+        Reflect.defineMetadata(BEFORE_KEY, hooks, target, propertyKey);
+    };
+}
+/**
+ * Decorator that registers a function to run after route handler execution.
+ * Can access the handler's result.
+ *
+ * @param fn - Function to execute after the handler
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/users/:id')
+ * @After((req, res, result) => console.log(`User data sent: ${JSON.stringify(result)}`))
+ * getUser(@Param('id') id: string) {
+ *   // After this handler, the function will log the returned data
+ *   return { id, name: 'Example' };
+ * }
+ * ```
+ */
+export function After(fn) {
+    return function (target, propertyKey, _descriptor) {
+        var hooks = Reflect.getMetadata(AFTER_KEY, target, propertyKey) || [];
+        hooks.push(fn);
+        Reflect.defineMetadata(AFTER_KEY, hooks, target, propertyKey);
+    };
+}
+/**
+ * Decorator that requires specific roles for accessing a route.
+ * Must be used with authentication middleware.
+ *
+ * @param roles - List of roles that can access this route
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/admin/settings')
+ * @Roles('admin', 'superuser')
+ * getSettings() {
+ *   // Only admins and superusers can access
+ *   return { settings: [...] };
+ * }
+ * ```
+ */
+export function Roles() {
+    var roles = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        roles[_i] = arguments[_i];
+    }
+    return function (target, propertyKey, _descriptor) {
+        Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+    };
+}
+/**
+ * Decorator that redirects to another URL.
+ *
+ * @param url - URL to redirect to (can be absolute or relative)
+ * @param statusCode - HTTP status code for redirect (default: 302)
+ * @returns Method decorator
+ *
+ * @example
+ * ```ts
+ * @Get('/old-path')
+ * @Redirect('/new-path', 301)
+ * redirectToNewPath() {
+ *   // This method won't be executed; automatic redirect happens
+ * }
+ *
+ * @Get('/dynamic-redirect')
+ * @Redirect()
+ * getDynamicRedirect() {
+ *   // Return an object with url and optionally statusCode
+ *   return { url: '/calculated-path', statusCode: 307 };
+ * }
+ * ```
+ */
+export function Redirect(url, statusCode) {
+    if (statusCode === void 0) { statusCode = 302; }
+    return function (target, propertyKey, descriptor) {
+        // Store the redirect information in metadata
+        Reflect.defineMetadata(REDIRECT_KEY, { url: url, statusCode: statusCode }, target, propertyKey);
+        return descriptor;
+    };
+}
+/**
+ * Registers all controller classes with the provided router.
+ * This function processes all decorators and sets up the Express routes.
+ *
+ * @param router - Express router instance
+ * @param controllers - Array of controller classes
+ */
+export function registerControllers(router, controllers) {
+    var _this = this;
+    controllers.forEach(function (ControllerClass) {
+        var instance = new ControllerClass();
+        var basePath = Reflect.getMetadata('basePath', ControllerClass) || '';
+        var routes = Reflect.getMetadata(ROUTES_KEY, ControllerClass) || [];
+        routes.forEach(function (_a) {
+            var _b;
+            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) || {};
+            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 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 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]);
+                            // 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'));
+                                return [2 /*return*/];
+                            }
+                            // Process static redirect if configured
+                            if (redirect && redirect.url) {
+                                return [2 /*return*/, res.redirect(redirect.statusCode, redirect.url)];
+                            }
+                            _o.label = 1;
+                        case 1:
+                            _o.trys.push([1, 6, 7, 8]);
+                            beforeHooks_1 = __values(beforeHooks), beforeHooks_1_1 = beforeHooks_1.next();
+                            _o.label = 2;
+                        case 2:
+                            if (!!beforeHooks_1_1.done) return [3 /*break*/, 5];
+                            fn = beforeHooks_1_1.value;
+                            return [4 /*yield*/, fn(req, res)];
+                        case 3:
+                            _o.sent();
+                            _o.label = 4;
+                        case 4:
+                            beforeHooks_1_1 = beforeHooks_1.next();
+                            return [3 /*break*/, 2];
+                        case 5: return [3 /*break*/, 8];
+                        case 6:
+                            e_1_1 = _o.sent();
+                            e_1 = { error: e_1_1 };
+                            return [3 /*break*/, 8];
+                        case 7:
+                            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:
+                            args_1 = [];
+                            if (params.length) {
+                                params.forEach(function (_a) {
+                                    var _b;
+                                    var index = _a.index, type = _a.type, key = _a.key;
+                                    switch (type) {
+                                        case 'query':
+                                            args_1[index] = key ? req.query[key] : req.query;
+                                            break;
+                                        case 'param':
+                                            args_1[index] = key ? req.params[key] : req.params;
+                                            break;
+                                        case 'body':
+                                            args_1[index] = key ? (_b = req.body) === null || _b === void 0 ? void 0 : _b[key] : req.body;
+                                            break;
+                                        case 'req':
+                                            args_1[index] = req;
+                                            break;
+                                        case 'res':
+                                            args_1[index] = res;
+                                            break;
+                                    }
+                                });
+                            }
+                            result = (_f = instance)[handlerName].apply(_f, __spreadArray([], __read(args_1), false));
+                            if (!(result instanceof Promise)) return [3 /*break*/, 10];
+                            return [4 /*yield*/, result];
+                        case 9:
+                            _a = _o.sent();
+                            return [3 /*break*/, 11];
+                        case 10:
+                            _a = result;
+                            _o.label = 11;
+                        case 11:
+                            awaited = _a;
+                            // Handle dynamic redirects
+                            if (redirect && awaited && typeof awaited === 'object' && 'url' in awaited) {
+                                redirectUrl = awaited.url;
+                                redirectStatus = awaited.statusCode || redirect.statusCode;
+                                return [2 /*return*/, res.redirect(redirectStatus, redirectUrl)];
+                            }
+                            if (!res.headersSent && typeof awaited !== 'undefined') {
+                                if (httpCode)
+                                    (_l = res.status) === null || _l === void 0 ? void 0 : _l.call(res, 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);
+                                    }
+                                }
+                                catch (e_3_1) { e_3 = { error: e_3_1 }; }
+                                finally {
+                                    try {
+                                        if (_c && !_c.done && (_g = _b.return)) _g.call(_b);
+                                    }
+                                    finally { if (e_3) throw e_3.error; }
+                                }
+                                res.json(awaited);
+                            }
+                            _o.label = 12;
+                        case 12:
+                            _o.trys.push([12, 17, 18, 19]);
+                            afterHooks_1 = __values(afterHooks), afterHooks_1_1 = afterHooks_1.next();
+                            _o.label = 13;
+                        case 13:
+                            if (!!afterHooks_1_1.done) return [3 /*break*/, 16];
+                            fn = afterHooks_1_1.value;
+                            return [4 /*yield*/, fn(req, res, awaited)];
+                        case 14:
+                            _o.sent();
+                            _o.label = 15;
+                        case 15:
+                            afterHooks_1_1 = afterHooks_1.next();
+                            return [3 /*break*/, 13];
+                        case 16: return [3 /*break*/, 19];
+                        case 17:
+                            e_2_1 = _o.sent();
+                            e_2 = { error: e_2_1 };
+                            return [3 /*break*/, 19];
+                        case 18:
+                            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:
+                            err_1 = _o.sent();
+                            next(err_1);
+                            return [3 /*break*/, 21];
+                        case 21: return [2 /*return*/];
+                    }
+                });
+            }); };
+            (_b = router)[method].apply(_b, __spreadArray(__spreadArray([basePath + path], __read(middlewares), false), [handler], false));
+        });
+    });
+}
+//# sourceMappingURL=decorators.utils.js.map