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

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

@@ -21,89 +21,6 @@
  * 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) {
-        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 { getLogger } from './logger.utils';
 import { createFinalErrorResponse } from './response.utils';
@@ -111,78 +28,146 @@ import { HttpStatusCodes } from './http-status-codes';
 import { rateLimit } from 'express-rate-limit';
 import { TTLCache } from './cache.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');
-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');
+const ROUTES_KEY = Symbol('routes');
+const MIDDLEWARE_KEY = Symbol('middlewares');
+const PARAMS_KEY = Symbol('params');
+const HTTP_CODE_KEY = Symbol('httpCode');
+const HEADER_KEY = Symbol('headers');
+const BEFORE_KEY = Symbol('before');
+const AFTER_KEY = Symbol('after');
+const ROLES_KEY = Symbol('roles');
+const REDIRECT_KEY = Symbol('redirect');
+const CACHE_KEY = Symbol('cache');
+const RATE_LIMIT_KEY = Symbol('rateLimit');
+const CONTENT_TYPE_KEY = Symbol('contentType');
+const VERSION_KEY = Symbol('version');
+const TIMEOUT_KEY = Symbol('timeout');
+const 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; }
+class RateLimiterCache {
+    cache;
+    constructor(maxSize = 100, ttlMs = 5 * 60 * 1000) {
         this.cache = new TTLCache({
-            maxSize: maxSize,
-            ttlMs: ttlMs
+            maxSize,
+            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);
+    generateKey(options) {
+        return `${options.max}:${options.windowMs}:${options.standardHeaders}:${options.legacyHeaders}`;
+    }
+    get(options) {
+        const key = this.generateKey(options);
+        const 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');
+        const limiter = rateLimit({
+            ...options,
+            handler: (req, res) => {
+                const 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,
+            limiter,
             config: key
         });
         return limiter;
-    };
-    RateLimiterCache.prototype.clear = function () {
+    }
+    clear() {
         this.cache.clear();
-    };
-    RateLimiterCache.prototype.size = function () {
+    }
+    size() {
         return this.cache.size();
-    };
-    RateLimiterCache.prototype.destroy = function () {
+    }
+    destroy() {
         this.cache.destroy();
-    };
-    return RateLimiterCache;
-}());
-export { RateLimiterCache };
+    }
+}
 // Global cache instance
-var rateLimiterCache = new RateLimiterCache();
+const rateLimiterCache = new RateLimiterCache();
+export class DIContainer {
+    instances = new Map();
+    constructing = new Map();
+    register(target) {
+        // Mark as injectable, but do not instantiate yet
+        if (!this.instances.has(target) && !this.constructing.has(target)) {
+            // No-op: instantiation is deferred until get()
+        }
+    }
+    get(target) {
+        // Return existing instance if available
+        if (this.instances.has(target)) {
+            return this.instances.get(target);
+        }
+        // If currently constructing, return the proxy (for circular refs)
+        if (this.constructing.has(target)) {
+            return this.constructing.get(target);
+        }
+        // Mark as constructing (for circular dependency support)
+        let proxy = {};
+        this.constructing.set(target, proxy);
+        // Resolve constructor dependencies
+        const paramTypes = Reflect.getMetadata('design:paramtypes', target) || [];
+        const dependencies = paramTypes.map(dep => this.get(dep));
+        const instance = new target(...dependencies);
+        // Copy instance properties to proxy (for circular refs)
+        Object.assign(proxy, instance);
+        // Replace proxy with real instance
+        this.instances.set(target, proxy);
+        this.constructing.delete(target);
+        // Copy prototype (for instanceof checks)
+        Object.setPrototypeOf(proxy, target.prototype);
+        return proxy;
+    }
+    clear() {
+        this.instances.clear();
+        this.constructing.clear();
+    }
+}
+const diContainer = new DIContainer();
 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'; })) {
+    if (Array.isArray(value) && value.every(item => typeof item === 'string')) {
         return value;
     }
     return String(value);
 }
+/**
+ * Injectable decorator for marking classes as injectable.
+ *
+ * @returns Class decorator that marks a class as injectable and registers it with the DI container.
+ */
+export function Injectable() {
+    return target => {
+        Reflect.defineMetadata('injectable', true, target);
+        diContainer.register(target);
+    };
+}
+/**
+ * Inject decorator for injecting dependencies into class properties.
+ *
+ * @param targetClass - The class to inject
+ * @returns Property decorator that injects the specified class into the property
+ */
+export function Inject(targetClass) {
+    return (target, propertyKey) => {
+        Object.defineProperty(target, propertyKey, {
+            get: function () {
+                return diContainer.get(targetClass);
+            },
+            enumerable: true,
+            configurable: true
+        });
+    };
+}
 /**
  * Factory function that creates HTTP method decorators.
  *
@@ -190,12 +175,12 @@ function normalizeHeaderValue(value) {
  * @returns A method decorator function
  */
 function createRouteDecorator(method) {
-    return function (path) {
-        return function (target, propertyKey, descriptor) {
-            var routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
+    return (path) => {
+        return (target, propertyKey, descriptor) => {
+            const routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
             routes.push({
-                path: path,
-                method: method,
+                path,
+                method,
                 handlerName: propertyKey
             });
             Reflect.defineMetadata(ROUTES_KEY, routes, target.constructor);
@@ -216,7 +201,7 @@ function createRouteDecorator(method) {
  * }
  * ```
  */
-export var Get = createRouteDecorator('get');
+export const Get = createRouteDecorator('get');
 /**
  * Decorator for POST HTTP method routes.
  *
@@ -231,56 +216,56 @@ export var Get = createRouteDecorator('get');
  * }
  * ```
  */
-export var Post = createRouteDecorator('post');
+export const Post = createRouteDecorator('post');
 /**
  * Decorator for PUT HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Put = createRouteDecorator('put');
+export const Put = createRouteDecorator('put');
 /**
  * Decorator for PATCH HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Patch = createRouteDecorator('patch');
+export const Patch = createRouteDecorator('patch');
 /**
  * Decorator for DELETE HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Delete = createRouteDecorator('delete');
+export const Delete = createRouteDecorator('delete');
 /**
  * Decorator for OPTIONS HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Options = createRouteDecorator('options');
+export const Options = createRouteDecorator('options');
 /**
  * Decorator for HEAD HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Head = createRouteDecorator('head');
+export const Head = createRouteDecorator('head');
 /**
  * Decorator for TRACE HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Trace = createRouteDecorator('trace');
+export const Trace = createRouteDecorator('trace');
 /**
  * Decorator for CONNECT HTTP method routes.
  *
  * @param path - URL path for the route
  * @returns Method decorator
  */
-export var Connect = createRouteDecorator('connect');
+export const Connect = createRouteDecorator('connect');
 /**
  * Decorator that marks a class as a controller with a base path.
  * Used as the entry point for routing configuration.
@@ -297,7 +282,7 @@ export var Connect = createRouteDecorator('connect');
  * ```
  */
 export function Controller(basePath) {
-    return function (target) {
+    return target => {
         Reflect.defineMetadata('basePath', basePath, target);
     };
 }
@@ -317,14 +302,10 @@ export function Controller(basePath) {
  * }
  * ```
  */
-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);
+export function Use(...middlewares) {
+    return (target, propertyKey, _descriptor) => {
+        const existing = Reflect.getMetadata(MIDDLEWARE_KEY, target, propertyKey) || [];
+        Reflect.defineMetadata(MIDDLEWARE_KEY, [...existing, ...middlewares], target, propertyKey);
     };
 }
 /**
@@ -335,12 +316,12 @@ export function Use() {
  * @returns Parameter decorator function
  */
 function createParamDecorator(type, key) {
-    return function (paramKey) {
-        return function (target, propertyKey, parameterIndex) {
-            var params = Reflect.getMetadata(PARAMS_KEY, target, propertyKey) || [];
+    return (paramKey) => {
+        return (target, propertyKey, parameterIndex) => {
+            const 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; });
+            params.push({ index: parameterIndex, type, key: paramKey || key });
+            params.sort((a, b) => a.index - b.index);
             Reflect.defineMetadata(PARAMS_KEY, params, target, propertyKey);
         };
     };
@@ -359,7 +340,7 @@ function createParamDecorator(type, key) {
  * }
  * ```
  */
-export var Query = createParamDecorator('query');
+export const Query = createParamDecorator('query');
 /**
  * Decorator that extracts route parameters from request.
  *
@@ -374,7 +355,7 @@ export var Query = createParamDecorator('query');
  * }
  * ```
  */
-export var Param = createParamDecorator('param');
+export const Param = createParamDecorator('param');
 /**
  * Decorator that extracts body or body property from request.
  *
@@ -394,7 +375,7 @@ export var Param = createParamDecorator('param');
  * }
  * ```
  */
-export var Body = createParamDecorator('body');
+export const Body = createParamDecorator('body');
 /**
  * Decorator that injects the entire request object.
  *
@@ -409,7 +390,7 @@ export var Body = createParamDecorator('body');
  * }
  * ```
  */
-export var Req = createParamDecorator('req');
+export const Req = createParamDecorator('req');
 /**
  * Decorator that injects the response object.
  *
@@ -424,7 +405,7 @@ export var Req = createParamDecorator('req');
  * }
  * ```
  */
-export var Res = createParamDecorator('res');
+export const Res = createParamDecorator('res');
 /**
  * Decorator that sets a custom HTTP status code for a response.
  *
@@ -442,7 +423,7 @@ export var Res = createParamDecorator('res');
  * ```
  */
 export function HttpCode(status) {
-    return function (target, propertyKey, _descriptor) {
+    return (target, propertyKey, _descriptor) => {
         Reflect.defineMetadata(HTTP_CODE_KEY, status, target, propertyKey);
     };
 }
@@ -495,11 +476,19 @@ export function Header(name, value) {
  * ```
  */
 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);
+    return (target, propertyKey) => {
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            const existing = Reflect.getMetadata(HEADER_KEY, target) || {};
+            const newHeaders = typeof headers === 'string' ? { [headers]: value } : headers;
+            Reflect.defineMetadata(HEADER_KEY, { ...existing, ...newHeaders }, target);
+        }
+        else {
+            // Method decorator
+            const existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
+            const newHeaders = typeof headers === 'string' ? { [headers]: value } : headers;
+            Reflect.defineMetadata(HEADER_KEY, { ...existing, ...newHeaders }, target, propertyKey);
+        }
     };
 }
 /**
@@ -519,8 +508,8 @@ export function Headers(headers, value) {
  * ```
  */
 export function Before(fn) {
-    return function (target, propertyKey, _descriptor) {
-        var hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
+    return (target, propertyKey, _descriptor) => {
+        const hooks = Reflect.getMetadata(BEFORE_KEY, target, propertyKey) || [];
         hooks.push(fn);
         Reflect.defineMetadata(BEFORE_KEY, hooks, target, propertyKey);
     };
@@ -543,8 +532,8 @@ export function Before(fn) {
  * ```
  */
 export function After(fn) {
-    return function (target, propertyKey, _descriptor) {
-        var hooks = Reflect.getMetadata(AFTER_KEY, target, propertyKey) || [];
+    return (target, propertyKey, _descriptor) => {
+        const hooks = Reflect.getMetadata(AFTER_KEY, target, propertyKey) || [];
         hooks.push(fn);
         Reflect.defineMetadata(AFTER_KEY, hooks, target, propertyKey);
     };
@@ -553,6 +542,8 @@ export function After(fn) {
  * Decorator that requires specific roles for accessing a route.
  * Must be used with authentication middleware.
  *
+ * Check req.user.roles for user roles[].
+ *
  * @param roles - List of roles that can access this route
  * @returns Method decorator
  *
@@ -566,13 +557,16 @@ export function After(fn) {
  * }
  * ```
  */
-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);
+export function Roles(...roles) {
+    return (target, propertyKey, _descriptor) => {
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(ROLES_KEY, roles, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+        }
     };
 }
 /**
@@ -598,11 +592,10 @@ export function Roles() {
  * }
  * ```
  */
-export function Redirect(url, statusCode) {
-    if (statusCode === void 0) { statusCode = 302; }
-    return function (target, propertyKey, descriptor) {
+export function Redirect(url, statusCode = 302) {
+    return (target, propertyKey, descriptor) => {
         // Store the redirect information in metadata
-        Reflect.defineMetadata(REDIRECT_KEY, { url: url, statusCode: statusCode }, target, propertyKey);
+        Reflect.defineMetadata(REDIRECT_KEY, { url, statusCode }, target, propertyKey);
         return descriptor;
     };
 }
@@ -622,8 +615,15 @@ export function Redirect(url, statusCode) {
  * ```
  */
 export function Cache(ttlSeconds) {
-    return function (target, propertyKey, _descriptor) {
-        Reflect.defineMetadata(CACHE_KEY, { ttlSeconds: ttlSeconds }, target, propertyKey);
+    return (target, propertyKey, _descriptor) => {
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(CACHE_KEY, { ttlSeconds }, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(CACHE_KEY, { ttlSeconds }, target, propertyKey);
+        }
     };
 }
 /**
@@ -648,9 +648,20 @@ export function Cache(ttlSeconds) {
  * ```
  */
 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);
+    const opts = {
+        standardHeaders: true,
+        legacyHeaders: false,
+        ...options
+    };
+    return (target, propertyKey, _descriptor) => {
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
+        }
     };
 }
 /**
@@ -669,8 +680,8 @@ export function RateLimit(options) {
  * ```
  */
 export function ContentType(type) {
-    return function (target, propertyKey, _descriptor) {
-        Reflect.defineMetadata(CONTENT_TYPE_KEY, { type: type }, target, propertyKey);
+    return (target, propertyKey, _descriptor) => {
+        Reflect.defineMetadata(CONTENT_TYPE_KEY, { type }, target, propertyKey);
     };
 }
 /**
@@ -703,9 +714,21 @@ export function ContentType(type) {
  * ```
  */
 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);
+    const opts = {
+        addPrefix: true,
+        addHeader: true,
+        headerName: 'X-API-Version',
+        ...options
+    };
+    return (target, propertyKey, _descriptor) => {
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(VERSION_KEY, { version, options: opts }, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(VERSION_KEY, { version, options: opts }, target, propertyKey);
+        }
     };
 }
 /**
@@ -724,8 +747,15 @@ export function Version(version, options) {
  * ```
  */
 export function Timeout(ms) {
-    return function (target, propertyKey, _descriptor) {
-        Reflect.defineMetadata(TIMEOUT_KEY, { ms: ms }, target, propertyKey);
+    return (target, propertyKey, _descriptor) => {
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(TIMEOUT_KEY, { ms }, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(TIMEOUT_KEY, { ms }, target, propertyKey);
+        }
     };
 }
 /**
@@ -757,9 +787,23 @@ export function Timeout(ms) {
  * ```
  */
 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);
+    return (target, propertyKey, _descriptor) => {
+        const config = {
+            logEntry: true,
+            logExit: true,
+            logBody: false,
+            logParams: false,
+            logResponse: false,
+            ...options
+        };
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(LOG_KEY, config, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(LOG_KEY, config, target, propertyKey);
+        }
     };
 }
 /**
@@ -770,288 +814,200 @@ export function Log(options) {
  * @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) || [];
+    controllers.forEach(ControllerClass => {
+        // Use DI container to resolve controller (constructor injection + property injection)
+        const instance = diContainer.get(ControllerClass);
+        const basePath = Reflect.getMetadata('basePath', ControllerClass) || '';
+        const 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);
+        const controllerRateLimit = Reflect.getMetadata(RATE_LIMIT_KEY, ControllerClass);
+        const controllerCache = Reflect.getMetadata(CACHE_KEY, ControllerClass);
+        const controllerTimeout = Reflect.getMetadata(TIMEOUT_KEY, ControllerClass);
+        const controllerVersion = Reflect.getMetadata(VERSION_KEY, ControllerClass);
+        const controllerRoles = Reflect.getMetadata(ROLES_KEY, ControllerClass);
+        const controllerLogConfig = Reflect.getMetadata(LOG_KEY, ControllerClass);
+        const controllerHeaders = Reflect.getMetadata(HEADER_KEY, ControllerClass) || {};
+        routes.forEach(({ path, method, handlerName }) => {
+            const middlewares = Reflect.getMetadata(MIDDLEWARE_KEY, instance, handlerName) || [];
+            const params = Reflect.getMetadata(PARAMS_KEY, instance, handlerName) || [];
+            const httpCode = Reflect.getMetadata(HTTP_CODE_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 redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
-            var contentType = Reflect.getMetadata(CONTENT_TYPE_KEY, instance, handlerName);
+            const methodHeaders = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
+            const headers = { ...controllerHeaders, ...methodHeaders };
+            const beforeHooks = Reflect.getMetadata(BEFORE_KEY, instance, handlerName) || [];
+            const afterHooks = Reflect.getMetadata(AFTER_KEY, instance, handlerName) || [];
+            const redirect = Reflect.getMetadata(REDIRECT_KEY, instance, handlerName);
+            const 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;
+            const roles = Reflect.getMetadata(ROLES_KEY, instance, handlerName) || controllerRoles || [];
+            const cache = Reflect.getMetadata(CACHE_KEY, instance, handlerName) || controllerCache;
+            const rateLimitOptions = Reflect.getMetadata(RATE_LIMIT_KEY, instance, handlerName) || controllerRateLimit;
+            const version = Reflect.getMetadata(VERSION_KEY, instance, handlerName) || controllerVersion;
+            const timeout = Reflect.getMetadata(TIMEOUT_KEY, instance, handlerName) || controllerTimeout;
+            const logConfig = Reflect.getMetadata(LOG_KEY, instance, handlerName) || controllerLogConfig;
             // Create rate limiter for this specific route if needed
-            var rateLimiter = null;
+            let 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');
+                    getLogger().warn({ 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);
+            let finalPath = path;
+            if (version?.options?.addPrefix) {
+                finalPath = `/${version.version}${path}`;
             }
-            var handler = function (req, res, next) { return __awaiter(_this, void 0, void 0, function () {
-                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:
-                            // 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 && !((_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 = 4;
-                        case 4:
-                            _o.trys.push([4, 9, 10, 11]);
-                            beforeHooks_1 = __values(beforeHooks), beforeHooks_1_1 = beforeHooks_1.next();
-                            _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 6:
-                            _o.sent();
-                            _o.label = 7;
-                        case 7:
-                            beforeHooks_1_1 = beforeHooks_1.next();
-                            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*/, 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 11:
-                            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*/, 13];
-                            return [4 /*yield*/, result];
-                        case 12:
-                            _a = _o.sent();
-                            return [3 /*break*/, 14];
-                        case 13:
-                            _a = result;
-                            _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;
-                                redirectStatus = awaited.statusCode || redirect.statusCode;
-                                return [2 /*return*/, res.redirect(redirectStatus, redirectUrl)];
-                            }
-                            if (!res.headersSent && typeof awaited !== 'undefined') {
-                                if (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];
-                                        normalized = normalizeHeaderValue(v);
-                                        if (typeof normalized !== 'undefined') {
-                                            res.set(k, normalized);
-                                        }
-                                    }
-                                }
-                                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);
-                            }
-                            // 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:');
+            const handler = async (req, res, next) => {
+                // Set start time for duration tracking
+                req['startTime'] = Date.now();
+                let timeoutId;
+                let timedOut = false;
+                try {
+                    // Handle timeout setup
+                    if (timeout) {
+                        timeoutId = setTimeout(() => {
+                            if (!res.headersSent && !timedOut) {
+                                timedOut = true;
+                                const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.REQUEST_TIMEOUT, 'Request timed out');
+                                res.status(HttpStatusCodes.REQUEST_TIMEOUT).json(errorResponse);
                             }
-                            _o.label = 15;
-                        case 15:
-                            _o.trys.push([15, 20, 21, 22]);
-                            afterHooks_1 = __values(afterHooks), afterHooks_1_1 = afterHooks_1.next();
-                            _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 17:
-                            _o.sent();
-                            _o.label = 18;
-                        case 18:
-                            afterHooks_1_1 = afterHooks_1.next();
-                            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*/, 22];
-                        case 21:
-                            try {
-                                if (afterHooks_1_1 && !afterHooks_1_1.done && (_h = afterHooks_1.return)) _h.call(afterHooks_1);
+                        }, timeout.ms);
+                    }
+                    if (timedOut)
+                        return;
+                    // Handle rate limiting
+                    if (rateLimiter) {
+                        await new Promise((resolve, reject) => {
+                            rateLimiter(req, res, (err) => {
+                                if (err)
+                                    reject(err);
+                                else
+                                    resolve();
+                            });
+                        });
+                    }
+                    // Handle content type
+                    if (!res.headersSent && contentType) {
+                        res.setHeader('Content-Type', contentType.type);
+                    }
+                    // Handle versioning header
+                    if (version?.options?.addHeader && version?.options?.headerName && 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=${cache.ttlSeconds}`);
+                    }
+                    // Handle logging - entry
+                    if (logConfig?.logEntry) {
+                        const logger = getLogger();
+                        const 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 && !req?.user?.roles?.some((role) => roles.includes(role))) {
+                        const errorResponse = createFinalErrorResponse(req, HttpStatusCodes.FORBIDDEN, 'Forbidden Insufficient Roles');
+                        res.status(HttpStatusCodes.FORBIDDEN).json(errorResponse);
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        return;
+                    }
+                    // Process static redirect if configured
+                    if (redirect && redirect.url) {
+                        if (timeoutId) {
+                            clearTimeout(timeoutId);
+                        }
+                        return res.redirect(redirect.statusCode, redirect.url);
+                    }
+                    for (const fn of beforeHooks)
+                        await fn(req, res);
+                    const args = [];
+                    if (params.length) {
+                        params.forEach(({ index, type, key }) => {
+                            switch (type) {
+                                case 'query':
+                                    args[index] = key ? req.query[key] : req.query;
+                                    break;
+                                case 'param':
+                                    args[index] = key ? req.params[key] : req.params;
+                                    break;
+                                case 'body':
+                                    args[index] = key ? req.body?.[key] : req.body;
+                                    break;
+                                case 'req':
+                                    args[index] = req;
+                                    break;
+                                case 'res':
+                                    args[index] = res;
+                                    break;
                             }
-                            finally { if (e_2) throw e_2.error; }
-                            return [7 /*endfinally*/];
-                        case 22: return [3 /*break*/, 24];
-                        case 23:
-                            err_1 = _o.sent();
-                            if (timeoutId) {
-                                clearTimeout(timeoutId);
+                        });
+                    }
+                    const result = instance[handlerName](...args);
+                    // Support both sync and async handlers
+                    const awaited = result instanceof Promise ? await result : result;
+                    // Clear timeout if operation completed
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                    }
+                    if (timedOut)
+                        return;
+                    // Handle dynamic redirects
+                    if (redirect && awaited && typeof awaited === 'object' && 'url' in awaited) {
+                        const redirectUrl = awaited.url;
+                        const redirectStatus = awaited.statusCode || redirect.statusCode;
+                        return res.redirect(redirectStatus, redirectUrl);
+                    }
+                    if (!res.headersSent && typeof awaited !== 'undefined') {
+                        if (httpCode)
+                            res.status(httpCode);
+                        for (const [k, v] of Object.entries(headers)) {
+                            const normalized = normalizeHeaderValue(v);
+                            if (typeof normalized !== 'undefined') {
+                                res.set(k, normalized);
                             }
-                            next(err_1);
-                            return [3 /*break*/, 24];
-                        case 24: return [2 /*return*/];
+                        }
+                        res.json(awaited);
                     }
-                });
-            }); };
-            (_b = router)[method].apply(_b, __spreadArray(__spreadArray([basePath + finalPath], __read(middlewares), false), [handler], false));
+                    // Handle logging - exit
+                    if (logConfig?.logExit) {
+                        const logger = getLogger();
+                        const logData = {
+                            method: req.method,
+                            url: req.originalUrl || req.url,
+                            statusCode: res.statusCode,
+                            duration: `${Date.now() - req.startTime}ms`
+                        };
+                        if (logConfig.logResponse)
+                            logData.response = awaited;
+                        logger.info({ exit: logData }, 'Route Exit:');
+                    }
+                    for (const fn of afterHooks)
+                        await fn(req, res, awaited);
+                }
+                catch (err) {
+                    if (timeoutId) {
+                        clearTimeout(timeoutId);
+                    }
+                    next(err);
+                }
+            };
+            router[method](basePath + finalPath, ...middlewares, handler);
         });
     });
 }
-// Export for testing purposes
-export { rateLimiterCache };
-//# sourceMappingURL=decorators.utils.js.map