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

package/build/{src → cjs}/utils/context-store.utils.js

@@ -76,6 +76,11 @@ function getFromContext(key) {
  * ```
  */
 class ContextStore {
+    /**
+     * The underlying AsyncLocalStorage instance for context.
+     * @private
+     */
+    static storage = new async_hooks_1.AsyncLocalStorage();
     /**
      * Returns the raw AsyncLocalStorage instance for advanced access.
      *
@@ -93,7 +98,7 @@ class ContextStore {
      */
     static get(key) {
         const store = this.storage.getStore();
-        return store === null || store === void 0 ? void 0 : store[key];
+        return store?.[key];
     }
     /**
      * Sets a value in the current context store by symbol key.
@@ -215,7 +220,7 @@ class ContextStore {
     static extend(newValues, callback) {
         const currentStore = this.storage.getStore() || {};
         // Create new store with current values plus new ones
-        const newStore = Object.assign({}, currentStore);
+        const newStore = { ...currentStore };
         // Add new values
         Object.getOwnPropertySymbols(newValues).forEach(key => {
             newStore[key] = newValues[key];
@@ -230,24 +235,21 @@ class ContextStore {
      * @returns Express middleware function.
      */
     static createExpressMiddleware(initialValuesFactory = () => ({})) {
-        return (req, res, next) => {
+        return (req, _res, next) => {
             const initialValues = initialValuesFactory(req);
             ContextStore.run(initialValues, next);
         };
     }
 }
 exports.ContextStore = ContextStore;
-/**
- * The underlying AsyncLocalStorage instance for context.
- * @private
- */
-ContextStore.storage = new async_hooks_1.AsyncLocalStorage();
 /**
  * Type-safe wrapper for accessing and modifying context values with specific types.
  *
  * @typeParam T - The value type.
  */
 class TypedContextKey {
+    symbol;
+    defaultValue;
     /**
      * Creates a new typed context key.
      *
@@ -293,4 +295,3 @@ class TypedContextKey {
     }
 }
 exports.TypedContextKey = TypedContextKey;
-//# sourceMappingURL=context-store.utils.js.map

package/build/{esnext → cjs}/utils/crypto.utils.d.ts

@@ -157,4 +157,3 @@ export declare function createSignedToken(payload: Record<string, any>, secret:
  * @returns {object | null} Decoded payload if valid, null if invalid
  */
 export declare function verifySignedToken(token: string, secret: string): Record<string, any> | null;
-//# sourceMappingURL=crypto.utils.d.ts.map

package/build/{src → cjs}/utils/crypto.utils.js

@@ -250,7 +250,10 @@ async function decrypt(encryptedData, key, options = {}) {
  */
 function createSignedToken(payload, secret, expiresInSeconds = 3600) {
     // Create payload with expiration
-    const tokenPayload = Object.assign(Object.assign({}, payload), { exp: Math.floor(Date.now() / 1000) + expiresInSeconds });
+    const tokenPayload = {
+        ...payload,
+        exp: Math.floor(Date.now() / 1000) + expiresInSeconds
+    };
     // Convert to string
     const payloadStr = JSON.stringify(tokenPayload);
     // Base64 encode the payload
@@ -286,8 +289,7 @@ function verifySignedToken(token, secret) {
         }
         return payload;
     }
-    catch (_a) {
+    catch {
         return null;
     }
 }
-//# sourceMappingURL=crypto.utils.js.map

package/build/{src → cjs}/utils/date.utils.d.ts

@@ -156,4 +156,3 @@ export declare function isLeapYear(year: number | Date): boolean;
  * @returns Number of days in the month
  */
 export declare function daysInMonth(year: number | Date, month?: number): number;
-//# sourceMappingURL=date.utils.d.ts.map

package/build/{src → cjs}/utils/date.utils.js

@@ -142,7 +142,7 @@ function parseDate(input, fallback) {
         }
         return date;
     }
-    catch (_a) {
+    catch {
         return fallback || null;
     }
 }
@@ -393,4 +393,3 @@ function daysInMonth(year, month) {
     }
     return new Date(year, month + 1, 0).getDate();
 }
-//# sourceMappingURL=date.utils.js.map

package/build/{src → cjs}/utils/decorators.utils.d.ts

@@ -1,24 +1,26 @@
 import type { RequestHandler, Router } from 'express';
 import 'reflect-metadata';
-import { rateLimit } from 'express-rate-limit';
-/**
- * RateLimiter cache that uses TTLCache for automatic TTL and LRU handling.
- */
-export declare class RateLimiterCache {
-    private cache;
-    constructor(maxSize?: number, ttlMs?: number);
-    private generateKey;
-    get(options: {
-        max: number;
-        windowMs: number;
-        standardHeaders: boolean;
-        legacyHeaders: boolean;
-    }): ReturnType<typeof rateLimit>;
+type Constructor<T = any> = new (...args: any[]) => T;
+export declare class DIContainer {
+    private instances;
+    private constructing;
+    register<T>(target: Constructor<T>): void;
+    get<T>(target: Constructor<T>): T;
     clear(): void;
-    size(): number;
-    destroy(): void;
 }
-declare const rateLimiterCache: RateLimiterCache;
+/**
+ * Injectable decorator for marking classes as injectable.
+ *
+ * @returns Class decorator that marks a class as injectable and registers it with the DI container.
+ */
+export declare function Injectable(): ClassDecorator;
+/**
+ * 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 declare function Inject<T>(targetClass: new (...args: any[]) => T): PropertyDecorator;
 /**
  * Decorator for GET HTTP method routes.
  *
@@ -244,7 +246,7 @@ export declare function HttpCode(status: number): MethodDecorator;
  *   return { data: '...' };
  * }
  */
-export declare function Header(name: string, value: string): MethodDecorator;
+export declare function Header(name: string, value: string): MethodDecorator & ClassDecorator;
 /**
  * Decorator that adds a custom HTTP headers to the response.
  *
@@ -274,7 +276,7 @@ export declare function Header(name: string, value: string): MethodDecorator;
  *
  * ```
  */
-export declare function Headers(headers: Record<string, string> | string, value?: string): MethodDecorator;
+export declare function Headers(headers: Record<string, string> | string, value?: string): MethodDecorator & ClassDecorator;
 /**
  * Decorator that registers a function to run before route handler execution.
  * Useful for pre-processing or logging.
@@ -314,6 +316,8 @@ export declare function After(fn: Function): MethodDecorator;
  * 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
  *
@@ -327,7 +331,7 @@ export declare function After(fn: Function): MethodDecorator;
  * }
  * ```
  */
-export declare function Roles(...roles: string[]): MethodDecorator;
+export declare function Roles(...roles: string[]): MethodDecorator & ClassDecorator;
 /**
  * Decorator that redirects to another URL.
  *
@@ -367,7 +371,7 @@ export declare function Redirect(url?: string, statusCode?: number): MethodDecor
  * }
  * ```
  */
-export declare function Cache(ttlSeconds: number): MethodDecorator;
+export declare function Cache(ttlSeconds: number): MethodDecorator & ClassDecorator;
 /**
  * Decorator that applies rate limiting to a route.
  * Note: Requires 'express-rate-limit' package to be installed.
@@ -394,7 +398,7 @@ export declare function RateLimit(options: {
     windowMs: number;
     standardHeaders?: boolean;
     legacyHeaders?: boolean;
-}): MethodDecorator;
+}): MethodDecorator & ClassDecorator;
 /**
  * Decorator that sets the content type for the response.
  *
@@ -444,7 +448,7 @@ export declare function Version(version: string, options?: {
     addPrefix?: boolean;
     addHeader?: boolean;
     headerName?: string;
-}): MethodDecorator;
+}): MethodDecorator & ClassDecorator;
 /**
  * Decorator that sets a timeout for route execution.
  *
@@ -460,7 +464,7 @@ export declare function Version(version: string, options?: {
  * }
  * ```
  */
-export declare function Timeout(ms: number): MethodDecorator;
+export declare function Timeout(ms: number): MethodDecorator & ClassDecorator;
 /**
  * Decorator that adds comprehensive logging to a route.
  *
@@ -495,7 +499,7 @@ export declare function Log(options?: {
     logBody?: boolean;
     logParams?: boolean;
     logResponse?: boolean;
-}): MethodDecorator;
+}): MethodDecorator & ClassDecorator;
 /**
  * Registers all controller classes with the provided router.
  * This function processes all decorators and sets up the Express routes.
@@ -504,5 +508,4 @@ export declare function Log(options?: {
  * @param controllers - Array of controller classes
  */
 export declare function registerControllers(router: Router, controllers: any[]): void;
-export { rateLimiterCache };
-//# sourceMappingURL=decorators.utils.d.ts.map
+export {};

package/build/{src → cjs}/utils/decorators.utils.js

@@ -23,7 +23,9 @@
  * SOFTWARE.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.rateLimiterCache = exports.Res = exports.Req = exports.Body = exports.Param = exports.Query = exports.Connect = exports.Trace = exports.Head = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.RateLimiterCache = void 0;
+exports.Res = exports.Req = exports.Body = exports.Param = exports.Query = exports.Connect = exports.Trace = exports.Head = exports.Options = exports.Delete = exports.Patch = exports.Put = exports.Post = exports.Get = exports.DIContainer = void 0;
+exports.Injectable = Injectable;
+exports.Inject = Inject;
 exports.Controller = Controller;
 exports.Use = Use;
 exports.HttpCode = HttpCode;
@@ -66,6 +68,7 @@ const LOG_KEY = Symbol('log');
  * RateLimiter cache that uses TTLCache for automatic TTL and LRU handling.
  */
 class RateLimiterCache {
+    cache;
     constructor(maxSize = 100, ttlMs = 5 * 60 * 1000) {
         this.cache = new cache_utils_1.TTLCache({
             maxSize,
@@ -82,10 +85,13 @@ class RateLimiterCache {
             return cached.limiter;
         }
         // Create new limiter
-        const limiter = (0, express_rate_limit_1.rateLimit)(Object.assign(Object.assign({}, options), { handler: (req, res) => {
+        const limiter = (0, express_rate_limit_1.rateLimit)({
+            ...options,
+            handler: (req, res) => {
                 const errorResponse = (0, response_utils_1.createFinalErrorResponse)(req, http_status_codes_1.HttpStatusCodes.TOO_MANY_REQUESTS, 'Too Many Requests');
                 res.status(http_status_codes_1.HttpStatusCodes.TOO_MANY_REQUESTS).json(errorResponse);
-            } }));
+            }
+        });
         // Store in cache
         this.cache.set(key, {
             limiter,
@@ -103,10 +109,49 @@ class RateLimiterCache {
         this.cache.destroy();
     }
 }
-exports.RateLimiterCache = RateLimiterCache;
 // Global cache instance
 const rateLimiterCache = new RateLimiterCache();
-exports.rateLimiterCache = rateLimiterCache;
+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();
+    }
+}
+exports.DIContainer = DIContainer;
+const diContainer = new DIContainer();
 function normalizeHeaderValue(value) {
     if (typeof value === 'undefined')
         return undefined;
@@ -117,6 +162,34 @@ function normalizeHeaderValue(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.
+ */
+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
+ */
+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.
  *
@@ -125,7 +198,7 @@ function normalizeHeaderValue(value) {
  */
 function createRouteDecorator(method) {
     return (path) => {
-        return (target, propertyKey, descriptor) => {
+        return (target, propertyKey, _descriptor) => {
             const routes = Reflect.getMetadata(ROUTES_KEY, target.constructor) || [];
             routes.push({
                 path,
@@ -426,9 +499,18 @@ function Header(name, value) {
  */
 function Headers(headers, value) {
     return (target, propertyKey) => {
-        const existing = Reflect.getMetadata(HEADER_KEY, target, propertyKey) || {};
-        const newHeaders = typeof headers === 'string' ? { [headers]: value } : headers;
-        Reflect.defineMetadata(HEADER_KEY, Object.assign(Object.assign({}, existing), newHeaders), 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);
+        }
     };
 }
 /**
@@ -482,6 +564,8 @@ 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
  *
@@ -497,7 +581,14 @@ function After(fn) {
  */
 function Roles(...roles) {
     return (target, propertyKey, _descriptor) => {
-        Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(ROLES_KEY, roles, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(ROLES_KEY, roles, target, propertyKey);
+        }
     };
 }
 /**
@@ -547,7 +638,14 @@ function Redirect(url, statusCode = 302) {
  */
 function Cache(ttlSeconds) {
     return (target, propertyKey, _descriptor) => {
-        Reflect.defineMetadata(CACHE_KEY, { ttlSeconds }, target, propertyKey);
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(CACHE_KEY, { ttlSeconds }, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(CACHE_KEY, { ttlSeconds }, target, propertyKey);
+        }
     };
 }
 /**
@@ -572,9 +670,20 @@ function Cache(ttlSeconds) {
  * ```
  */
 function RateLimit(options) {
-    const opts = Object.assign({ standardHeaders: true, legacyHeaders: false }, options);
+    const opts = {
+        standardHeaders: true,
+        legacyHeaders: false,
+        ...options
+    };
     return (target, propertyKey, _descriptor) => {
-        Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(RATE_LIMIT_KEY, opts, target, propertyKey);
+        }
     };
 }
 /**
@@ -627,9 +736,21 @@ function ContentType(type) {
  * ```
  */
 function Version(version, options) {
-    const opts = Object.assign({ addPrefix: true, addHeader: true, headerName: 'X-API-Version' }, options);
+    const opts = {
+        addPrefix: true,
+        addHeader: true,
+        headerName: 'X-API-Version',
+        ...options
+    };
     return (target, propertyKey, _descriptor) => {
-        Reflect.defineMetadata(VERSION_KEY, { version, options: opts }, target, propertyKey);
+        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);
+        }
     };
 }
 /**
@@ -649,7 +770,14 @@ function Version(version, options) {
  */
 function Timeout(ms) {
     return (target, propertyKey, _descriptor) => {
-        Reflect.defineMetadata(TIMEOUT_KEY, { ms }, target, propertyKey);
+        if (typeof propertyKey === 'undefined') {
+            // Class decorator
+            Reflect.defineMetadata(TIMEOUT_KEY, { ms }, target);
+        }
+        else {
+            // Method decorator
+            Reflect.defineMetadata(TIMEOUT_KEY, { ms }, target, propertyKey);
+        }
     };
 }
 /**
@@ -682,8 +810,22 @@ function Timeout(ms) {
  */
 function Log(options) {
     return (target, propertyKey, _descriptor) => {
-        const config = Object.assign({ logEntry: true, logExit: true, logBody: false, logParams: false, logResponse: false }, options);
-        Reflect.defineMetadata(LOG_KEY, config, target, propertyKey);
+        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);
+        }
     };
 }
 /**
@@ -695,7 +837,8 @@ function Log(options) {
  */
 function registerControllers(router, controllers) {
     controllers.forEach(ControllerClass => {
-        const instance = new 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)
@@ -707,13 +850,12 @@ function registerControllers(router, controllers) {
         const controllerLogConfig = Reflect.getMetadata(LOG_KEY, ControllerClass);
         const controllerHeaders = Reflect.getMetadata(HEADER_KEY, ControllerClass) || {};
         routes.forEach(({ path, method, handlerName }) => {
-            var _a;
             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
             const methodHeaders = Reflect.getMetadata(HEADER_KEY, instance, handlerName) || {};
-            const headers = Object.assign(Object.assign({}, controllerHeaders), methodHeaders);
+            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);
@@ -736,11 +878,10 @@ function registerControllers(router, controllers) {
                 }
             }
             let finalPath = path;
-            if ((_a = version === null || version === void 0 ? void 0 : version.options) === null || _a === void 0 ? void 0 : _a.addPrefix) {
+            if (version?.options?.addPrefix) {
                 finalPath = `/${version.version}${path}`;
             }
             const handler = async (req, res, next) => {
-                var _a, _b, _c, _d;
                 // Set start time for duration tracking
                 req['startTime'] = Date.now();
                 let timeoutId;
@@ -774,7 +915,7 @@ function registerControllers(router, controllers) {
                         res.setHeader('Content-Type', contentType.type);
                     }
                     // Handle versioning header
-                    if (((_a = version === null || version === void 0 ? void 0 : version.options) === null || _a === void 0 ? void 0 : _a.addHeader) && ((_b = version === null || version === void 0 ? void 0 : version.options) === null || _b === void 0 ? void 0 : _b.headerName) && (version === null || version === void 0 ? void 0 : version.version)) {
+                    if (version?.options?.addHeader && version?.options?.headerName && version?.version) {
                         if (!res.headersSent) {
                             res.setHeader(version.options.headerName, version.version);
                         }
@@ -784,7 +925,7 @@ function registerControllers(router, controllers) {
                         res.setHeader('Cache-Control', `public, max-age=${cache.ttlSeconds}`);
                     }
                     // Handle logging - entry
-                    if (logConfig === null || logConfig === void 0 ? void 0 : logConfig.logEntry) {
+                    if (logConfig?.logEntry) {
                         const logger = (0, logger_utils_1.getLogger)();
                         const logData = {
                             method: req.method,
@@ -800,7 +941,7 @@ function registerControllers(router, controllers) {
                         logger.info({ entry: logData }, 'Route Entry:');
                     }
                     // Handle roles-based access control
-                    if (roles.length && !((_d = (_c = req === null || req === void 0 ? void 0 : req.user) === null || _c === void 0 ? void 0 : _c.roles) === null || _d === void 0 ? void 0 : _d.some((role) => roles.includes(role)))) {
+                    if (roles.length && !req?.user?.roles?.some((role) => roles.includes(role))) {
                         const errorResponse = (0, response_utils_1.createFinalErrorResponse)(req, http_status_codes_1.HttpStatusCodes.FORBIDDEN, 'Forbidden Insufficient Roles');
                         res.status(http_status_codes_1.HttpStatusCodes.FORBIDDEN).json(errorResponse);
                         if (timeoutId) {
@@ -820,7 +961,6 @@ function registerControllers(router, controllers) {
                     const args = [];
                     if (params.length) {
                         params.forEach(({ index, type, key }) => {
-                            var _a;
                             switch (type) {
                                 case 'query':
                                     args[index] = key ? req.query[key] : req.query;
@@ -829,7 +969,7 @@ function registerControllers(router, controllers) {
                                     args[index] = key ? req.params[key] : req.params;
                                     break;
                                 case 'body':
-                                    args[index] = key ? (_a = req.body) === null || _a === void 0 ? void 0 : _a[key] : req.body;
+                                    args[index] = key ? req.body?.[key] : req.body;
                                     break;
                                 case 'req':
                                     args[index] = req;
@@ -867,7 +1007,7 @@ function registerControllers(router, controllers) {
                         res.json(awaited);
                     }
                     // Handle logging - exit
-                    if (logConfig === null || logConfig === void 0 ? void 0 : logConfig.logExit) {
+                    if (logConfig?.logExit) {
                         const logger = (0, logger_utils_1.getLogger)();
                         const logData = {
                             method: req.method,
@@ -893,4 +1033,3 @@ function registerControllers(router, controllers) {
         });
     });
 }
-//# sourceMappingURL=decorators.utils.js.map

package/build/{esnext → cjs}/utils/dir.utils.d.ts

@@ -193,4 +193,3 @@ export declare function walkDir(dirPath: string, options: {
     }) => boolean | void | Promise<boolean | void>;
     traversalOrder?: 'pre' | 'post';
 }): Promise<void>;
-//# sourceMappingURL=dir.utils.d.ts.map

package/build/{src → cjs}/utils/dir.utils.js

@@ -105,7 +105,7 @@ async function isDirectory(pathStr) {
         const stat = await promises_1.default.stat(pathStr);
         return stat.isDirectory();
     }
-    catch (_a) {
+    catch {
         return false;
     }
 }
@@ -209,7 +209,7 @@ function watchDir(dirPath, callback) {
  * @throws {Error} If pattern matching fails.
  */
 async function findFilesByPattern(pattern, options = {}) {
-    const defaultOptions = Object.assign({ nodir: true }, options);
+    const defaultOptions = { nodir: true, ...options };
     return (0, glob_1.glob)(pattern, defaultOptions);
 }
 /**
@@ -273,7 +273,7 @@ async function createTempDir(options = {}) {
         try {
             await deleteDirRecursive(tempDirPath);
         }
-        catch (_a) {
+        catch {
             // Ignore cleanup errors
         }
     };
@@ -282,7 +282,7 @@ async function createTempDir(options = {}) {
             try {
                 fs_1.default.rmSync(tempDirPath, { recursive: true, force: true });
             }
-            catch (_a) {
+            catch {
                 // Ignore cleanup errors on exit
             }
         });
@@ -388,7 +388,7 @@ async function watchDirRecursive(dirPath, callback, includeSubdirs = true) {
                                 addWatcher(fullPath);
                             }
                         }
-                        catch (_a) {
+                        catch {
                             // Ignore errors checking newly created items
                         }
                     }, 100);
@@ -396,7 +396,7 @@ async function watchDirRecursive(dirPath, callback, includeSubdirs = true) {
             });
             watchers.push(watcher);
         }
-        catch (_a) {
+        catch {
             // Silently ignore directories we can't watch
         }
     };
@@ -498,4 +498,3 @@ async function walkDir(dirPath, options) {
         await options.visitorFn(entryInfo);
     }
 }
-//# sourceMappingURL=dir.utils.js.map

package/build/{esnext → cjs}/utils/env.utils.d.ts

@@ -374,4 +374,3 @@ export declare class Env {
      */
     static clearCache(): void;
 }
-//# sourceMappingURL=env.utils.d.ts.map