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

package/build/esm/utils/performance.utils.js

@@ -21,78 +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));
-};
 import { TTLCache } from './cache.utils';
 import { getLogger } from './logger.utils';
 /**
@@ -112,46 +40,45 @@ import { getLogger } from './logger.utils';
  * console.log(`Result: ${result}, took ${timing.durationMs}ms`);
  * ```
  */
-export function timeSync(fn, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.label, label = _a === void 0 ? fn.name || 'anonymous function' : _a, _b = options.log, log = _b === void 0 ? false : _b, _c = options.logLevel, logLevel = _c === void 0 ? 'debug' : _c;
-    var startTime = performance.now();
-    var result = fn();
-    var endTime = performance.now();
-    var durationMs = endTime - startTime;
-    var durationSec = durationMs / 1000;
-    var timing = {
-        durationMs: durationMs,
-        durationSec: durationSec,
-        startTime: startTime,
-        endTime: endTime,
-        label: label
+export function timeSync(fn, options = {}) {
+    const { label = fn.name || 'anonymous function', log = false, logLevel = 'debug' } = options;
+    const startTime = performance.now();
+    const result = fn();
+    const endTime = performance.now();
+    const durationMs = endTime - startTime;
+    const durationSec = durationMs / 1000;
+    const timing = {
+        durationMs,
+        durationSec,
+        startTime,
+        endTime,
+        label
     };
     if (log) {
-        var logger = getLogger();
-        var message = "".concat(label, " completed in ").concat(durationMs.toFixed(2), "ms");
+        const logger = getLogger();
+        const message = `${label} completed in ${durationMs.toFixed(2)}ms`;
         switch (logLevel) {
             case 'trace':
-                logger.trace({ timing: timing }, message);
+                logger.trace({ timing }, message);
                 break;
             case 'debug':
-                logger.debug({ timing: timing }, message);
+                logger.debug({ timing }, message);
                 break;
             case 'info':
-                logger.info({ timing: timing }, message);
+                logger.info({ timing }, message);
                 break;
             case 'warn':
-                logger.warn({ timing: timing }, message);
+                logger.warn({ timing }, message);
                 break;
             case 'error':
-                logger.error({ timing: timing }, message);
+                logger.error({ timing }, message);
                 break;
             default:
-                logger.debug({ timing: timing }, message);
+                logger.debug({ timing }, message);
                 break;
         }
     }
-    return { result: result, timing: timing };
+    return { result, timing };
 }
 /**
  * Measure the execution time of an asynchronous function.
@@ -171,56 +98,45 @@ export function timeSync(fn, options) {
  * console.log(`Fetched ${result.length} items in ${timing.durationSec.toFixed(2)}s`);
  * ```
  */
-export function timeAsync(fn_1) {
-    return __awaiter(this, arguments, void 0, function (fn, options) {
-        var _a, label, _b, log, _c, logLevel, startTime, result, endTime, durationMs, durationSec, timing, logger, message;
-        if (options === void 0) { options = {}; }
-        return __generator(this, function (_d) {
-            switch (_d.label) {
-                case 0:
-                    _a = options.label, label = _a === void 0 ? fn.name || 'anonymous async function' : _a, _b = options.log, log = _b === void 0 ? false : _b, _c = options.logLevel, logLevel = _c === void 0 ? 'debug' : _c;
-                    startTime = performance.now();
-                    return [4 /*yield*/, fn()];
-                case 1:
-                    result = _d.sent();
-                    endTime = performance.now();
-                    durationMs = endTime - startTime;
-                    durationSec = durationMs / 1000;
-                    timing = {
-                        durationMs: durationMs,
-                        durationSec: durationSec,
-                        startTime: startTime,
-                        endTime: endTime,
-                        label: label
-                    };
-                    if (log) {
-                        logger = getLogger();
-                        message = "".concat(label, " completed in ").concat(durationMs.toFixed(2), "ms");
-                        switch (logLevel) {
-                            case 'trace':
-                                logger.trace({ timing: timing }, message);
-                                break;
-                            case 'debug':
-                                logger.debug({ timing: timing }, message);
-                                break;
-                            case 'info':
-                                logger.info({ timing: timing }, message);
-                                break;
-                            case 'warn':
-                                logger.warn({ timing: timing }, message);
-                                break;
-                            case 'error':
-                                logger.error({ timing: timing }, message);
-                                break;
-                            default:
-                                logger.debug({ timing: timing }, message);
-                                break;
-                        }
-                    }
-                    return [2 /*return*/, { result: result, timing: timing }];
-            }
-        });
-    });
+export async function timeAsync(fn, options = {}) {
+    const { label = fn.name || 'anonymous async function', log = false, logLevel = 'debug' } = options;
+    const startTime = performance.now();
+    const result = await fn();
+    const endTime = performance.now();
+    const durationMs = endTime - startTime;
+    const durationSec = durationMs / 1000;
+    const timing = {
+        durationMs,
+        durationSec,
+        startTime,
+        endTime,
+        label
+    };
+    if (log) {
+        const logger = getLogger();
+        const message = `${label} completed in ${durationMs.toFixed(2)}ms`;
+        switch (logLevel) {
+            case 'trace':
+                logger.trace({ timing }, message);
+                break;
+            case 'debug':
+                logger.debug({ timing }, message);
+                break;
+            case 'info':
+                logger.info({ timing }, message);
+                break;
+            case 'warn':
+                logger.warn({ timing }, message);
+                break;
+            case 'error':
+                logger.error({ timing }, message);
+                break;
+            default:
+                logger.debug({ timing }, message);
+                break;
+        }
+    }
+    return { result, timing };
 }
 /**
  * Create a timing decorator for class methods.
@@ -238,37 +154,31 @@ export function timeAsync(fn_1) {
  * }
  * ```
  */
-export function timed(options) {
-    if (options === void 0) { options = {}; }
+export function timed(options = {}) {
     return function (target, propertyKeyOrContext, descriptor) {
-        var propertyKey;
-        var actualDescriptor;
+        let propertyKey;
+        let actualDescriptor;
         // ESNext decorator: second argument is context object
         if (typeof propertyKeyOrContext === 'object' && propertyKeyOrContext !== null && 'name' in propertyKeyOrContext) {
             propertyKey = propertyKeyOrContext.name;
-            actualDescriptor = descriptor !== null && descriptor !== void 0 ? descriptor : Object.getOwnPropertyDescriptor(target, propertyKey);
+            actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey);
         }
         else {
             // Legacy decorator: second argument is property key
             propertyKey = propertyKeyOrContext;
-            actualDescriptor = descriptor !== null && descriptor !== void 0 ? descriptor : Object.getOwnPropertyDescriptor(target, propertyKey);
+            actualDescriptor = descriptor ?? Object.getOwnPropertyDescriptor(target, propertyKey);
         }
-        var originalMethod = actualDescriptor.value;
-        actualDescriptor.value = function () {
-            var _this = this;
-            var args = [];
-            for (var _i = 0; _i < arguments.length; _i++) {
-                args[_i] = arguments[_i];
-            }
-            var methodOptions = __assign(__assign({}, options), { label: options.label || "".concat(target.constructor.name, ".").concat(String(propertyKey)) });
+        const originalMethod = actualDescriptor.value;
+        actualDescriptor.value = function (...args) {
+            const methodOptions = {
+                ...options,
+                label: options.label || `${target.constructor.name}.${String(propertyKey)}`
+            };
             if (originalMethod.constructor.name === 'AsyncFunction') {
-                return timeAsync(function () { return originalMethod.apply(_this, args); }, methodOptions).then(function (_a) {
-                    var result = _a.result;
-                    return result;
-                });
+                return timeAsync(() => originalMethod.apply(this, args), methodOptions).then(({ result }) => result);
             }
             else {
-                return timeSync(function () { return originalMethod.apply(_this, args); }, methodOptions).result;
+                return timeSync(() => originalMethod.apply(this, args), methodOptions).result;
             }
         };
         // For legacy decorators, assign the new descriptor
@@ -300,34 +210,23 @@ export function timed(options) {
  * );
  * ```
  */
-export function memoize(fn, options) {
-    if (options === void 0) { options = {}; }
-    var ttl = options.ttl, maxSize = options.maxSize, autoCleanupMs = options.autoCleanupMs, _a = options.cacheKey, cacheKey = _a === void 0 ? function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        return JSON.stringify(args);
-    } : _a;
+export function memoize(fn, options = {}) {
+    const { ttl, maxSize, autoCleanupMs, cacheKey = (...args) => JSON.stringify(args) } = options;
     // Create a properly configured TTLCache instance
-    var cache = new TTLCache({
+    const cache = new TTLCache({
         ttlMs: ttl,
         maxSize: maxSize,
         autoCleanupMs: autoCleanupMs
     });
-    return function () {
-        var args = [];
-        for (var _i = 0; _i < arguments.length; _i++) {
-            args[_i] = arguments[_i];
-        }
-        var key = cacheKey.apply(void 0, __spreadArray([], __read(args), false));
+    return function (...args) {
+        const key = cacheKey(...args);
         // Try to get from cache first - TTLCache handles expiration internally
-        var cachedValue = cache.get(key);
+        const cachedValue = cache.get(key);
         if (cachedValue !== undefined) {
             return cachedValue;
         }
         // Calculate the value and store in cache with configured TTL
-        var value = fn.apply(void 0, __spreadArray([], __read(args), false));
+        const value = fn(...args);
         cache.set(key, value);
         return value;
     };
@@ -339,38 +238,36 @@ export function memoize(fn, options) {
  * @param options - Memory tracking options
  * @returns Result and memory usage information
  */
-export function trackMemoryUsage(fn, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.log, log = _a === void 0 ? false : _a, _b = options.label, label = _b === void 0 ? fn.name || 'anonymous function' : _b;
+export function trackMemoryUsage(fn, options = {}) {
+    const { log = false, label = fn.name || 'anonymous function' } = options;
     // Collect garbage before measuring (optional)
     if (global.gc) {
         global.gc();
     }
-    var beforeMemory = process.memoryUsage();
-    var result = fn();
-    var afterMemory = process.memoryUsage();
+    const beforeMemory = process.memoryUsage();
+    const result = fn();
+    const afterMemory = process.memoryUsage();
     // Calculate differences
-    var diff = {};
-    for (var key in afterMemory) {
+    const diff = {};
+    for (const key in afterMemory) {
         if (Object.prototype.hasOwnProperty.call(afterMemory, key)) {
             diff[key] = afterMemory[key] - beforeMemory[key];
         }
     }
     if (log) {
         getLogger().info({
-            label: label,
+            label,
             memoryBefore: beforeMemory,
             memoryAfter: afterMemory,
             memoryDiff: diff
-        }, "Memory usage for ".concat(label));
+        }, `Memory usage for ${label}`);
     }
     return {
-        result: result,
+        result,
         memoryUsage: {
             before: beforeMemory,
             after: afterMemory,
-            diff: diff
+            diff
         }
     };
 }
-//# sourceMappingURL=performance.utils.js.map

package/build/esm/utils/request.utils.d.ts

@@ -83,4 +83,3 @@ export declare function extractSortParams(query: Record<string, string | string[
  * @returns Object containing the filters as key-value pairs
  */
 export declare function extractFilterParams(query: Record<string, string | string[]>, allowedFilters: string[]): Record<string, string | string[]>;
-//# sourceMappingURL=request.utils.d.ts.map

package/build/esm/utils/request.utils.js

@@ -21,28 +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 __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 { BadRequestException } from './exception.utils';
 /**
  * Extracts pagination, sorting, and optional search params from a request.
@@ -50,14 +28,21 @@ import { BadRequestException } from './exception.utils';
  * @param req - Express request
  * @returns Object containing validated pagination, sorting, and additional query params
  */
-export var getPaginationParams = function (req) {
-    var query = req.query;
+export const getPaginationParams = (req) => {
+    const query = req.query;
     // Extract page & limit
-    var _a = extractPaginationParams(query, 1, 20, 100), page = _a.page, limit = _a.limit;
-    var _b = extractSortParams(query, []), sortBy = _b.sortBy, sortOrder = _b.sortOrder;
+    const { page, limit } = extractPaginationParams(query, 1, 20, 100);
+    const { sortBy, sortOrder } = extractSortParams(query, []);
     // Optional search param
-    var search = typeof query.search === 'string' ? query.search : undefined;
-    return __assign(__assign({}, query), { page: page, limit: limit, sortBy: sortBy, sortOrder: sortOrder, search: search });
+    const search = typeof query.search === 'string' ? query.search : undefined;
+    return {
+        ...query,
+        page,
+        limit,
+        sortBy,
+        sortOrder: sortOrder,
+        search
+    };
 };
 /**
  * Safely parses a string parameter to a number.
@@ -66,16 +51,15 @@ export var getPaginationParams = function (req) {
  * @param options - Validation options
  * @returns Validation result containing the parsed number or error
  */
-export function parseNumberParam(value, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.throwOnError, throwOnError = _a === void 0 ? false : _a, _b = options.errorMessage, errorMessage = _b === void 0 ? 'Invalid number parameter' : _b, defaultValue = options.defaultValue, _c = options.required, required = _c === void 0 ? false : _c;
+export function parseNumberParam(value, options = {}) {
+    const { throwOnError = false, errorMessage = 'Invalid number parameter', defaultValue, required = false } = options;
     // Handle undefined case
     if (value === undefined) {
         if (required) {
-            var error = "Required number parameter is missing";
+            const error = `Required number parameter is missing`;
             if (throwOnError)
                 throw new BadRequestException(error);
-            return { isValid: false, value: null, error: error };
+            return { isValid: false, value: null, error };
         }
         return {
             isValid: defaultValue !== undefined,
@@ -84,7 +68,7 @@ export function parseNumberParam(value, options) {
         };
     }
     // Parse and validate the number
-    var num = Number(value);
+    const num = Number(value);
     if (isNaN(num)) {
         if (throwOnError)
             throw new BadRequestException(errorMessage);
@@ -99,16 +83,15 @@ export function parseNumberParam(value, options) {
  * @param options - Validation options
  * @returns Validation result containing the parsed boolean or error
  */
-export function parseBooleanParam(value, options) {
-    if (options === void 0) { options = {}; }
-    var _a = options.throwOnError, throwOnError = _a === void 0 ? false : _a, _b = options.errorMessage, errorMessage = _b === void 0 ? 'Invalid boolean parameter' : _b, defaultValue = options.defaultValue, _c = options.required, required = _c === void 0 ? false : _c;
+export function parseBooleanParam(value, options = {}) {
+    const { throwOnError = false, errorMessage = 'Invalid boolean parameter', defaultValue, required = false } = options;
     // Handle undefined case
     if (value === undefined) {
         if (required) {
-            var error = "Required boolean parameter is missing";
+            const error = `Required boolean parameter is missing`;
             if (throwOnError)
                 throw new BadRequestException(error);
-            return { isValid: false, value: null, error: error };
+            return { isValid: false, value: null, error };
         }
         return {
             isValid: defaultValue !== undefined,
@@ -117,7 +100,7 @@ export function parseBooleanParam(value, options) {
         };
     }
     // Parse the boolean value with various allowed formats
-    var lowercaseValue = value.toLowerCase();
+    const lowercaseValue = value.toLowerCase();
     if (['true', 't', 'yes', 'y', '1'].includes(lowercaseValue)) {
         return { isValid: true, value: true };
     }
@@ -137,20 +120,17 @@ export function parseBooleanParam(value, options) {
  * @param maxLimitSize - Maximum allowed per page size (defaults to 100)
  * @returns Object containing validated page and limit
  */
-export function extractPaginationParams(query, defaultPage, defaultLimit, maxLimitSize) {
-    if (defaultPage === void 0) { defaultPage = 1; }
-    if (defaultLimit === void 0) { defaultLimit = 20; }
-    if (maxLimitSize === void 0) { maxLimitSize = 100; }
+export function extractPaginationParams(query, defaultPage = 1, defaultLimit = 20, maxLimitSize = 100) {
     // Parse page parameter
-    var pageParam = typeof query.page === 'string' ? query.page : undefined;
-    var pageResult = parseNumberParam(pageParam, { defaultValue: defaultPage });
+    const pageParam = typeof query.page === 'string' ? query.page : undefined;
+    const pageResult = parseNumberParam(pageParam, { defaultValue: defaultPage });
     // Parse limit parameter
-    var limitParam = typeof query.limit === 'string' ? query.limit : undefined;
-    var limitResult = parseNumberParam(limitParam, { defaultValue: defaultLimit });
+    const limitParam = typeof query.limit === 'string' ? query.limit : undefined;
+    const limitResult = parseNumberParam(limitParam, { defaultValue: defaultLimit });
     // Ensure valid values (handle 0 → fallback to default)
-    var page = pageResult.value && pageResult.value > 0 ? pageResult.value : defaultPage;
-    var limit = limitResult.value && limitResult.value > 0 ? Math.min(limitResult.value, maxLimitSize) : defaultLimit;
-    return { page: page, limit: limit };
+    const page = pageResult.value && pageResult.value > 0 ? pageResult.value : defaultPage;
+    const limit = limitResult.value && limitResult.value > 0 ? Math.min(limitResult.value, maxLimitSize) : defaultLimit;
+    return { page, limit };
 }
 /**
  * Extracts sorting parameters from request query parameters.
@@ -160,10 +140,9 @@ export function extractPaginationParams(query, defaultPage, defaultLimit, maxLim
  * @param defaultSort - Default sort configuration if not specified
  * @returns Object containing sort field and direction
  */
-export function extractSortParams(query, allowedFields, defaultSort) {
-    if (defaultSort === void 0) { defaultSort = { sortBy: 'createdAt', sortOrder: 'desc' }; }
-    var sortBy = defaultSort.sortBy;
-    var sortOrder = defaultSort.sortOrder;
+export function extractSortParams(query, allowedFields, defaultSort = { sortBy: 'createdAt', sortOrder: 'desc' }) {
+    let sortBy = defaultSort.sortBy;
+    let sortOrder = defaultSort.sortOrder;
     // Extract from `sortBy` or `sort`
     if (typeof query.sortBy === 'string') {
         sortBy = query.sortBy;
@@ -181,7 +160,7 @@ export function extractSortParams(query, allowedFields, defaultSort) {
     }
     // Explicit sortOrder (overrides inferred one if valid)
     if (typeof query.sortOrder === 'string') {
-        var order = query.sortOrder.toLowerCase();
+        const order = query.sortOrder.toLowerCase();
         if (order === 'asc' || order === 'desc') {
             sortOrder = order;
         }
@@ -190,7 +169,7 @@ export function extractSortParams(query, allowedFields, defaultSort) {
     if (allowedFields.length && !allowedFields.includes(sortBy)) {
         sortBy = defaultSort.sortBy;
     }
-    return { sortBy: sortBy, sortOrder: sortOrder };
+    return { sortBy, sortOrder };
 }
 /**
  * Extracts filter parameters from query parameters based on allowed filter fields.
@@ -200,24 +179,12 @@ export function extractSortParams(query, allowedFields, defaultSort) {
  * @returns Object containing the filters as key-value pairs
  */
 export function extractFilterParams(query, allowedFilters) {
-    var e_1, _a;
-    var filters = {};
-    try {
-        // Find filter parameters in the query
-        for (var allowedFilters_1 = __values(allowedFilters), allowedFilters_1_1 = allowedFilters_1.next(); !allowedFilters_1_1.done; allowedFilters_1_1 = allowedFilters_1.next()) {
-            var field = allowedFilters_1_1.value;
-            if (field in query) {
-                filters[field] = query[field];
-            }
-        }
-    }
-    catch (e_1_1) { e_1 = { error: e_1_1 }; }
-    finally {
-        try {
-            if (allowedFilters_1_1 && !allowedFilters_1_1.done && (_a = allowedFilters_1.return)) _a.call(allowedFilters_1);
+    const filters = {};
+    // Find filter parameters in the query
+    for (const field of allowedFilters) {
+        if (field in query) {
+            filters[field] = query[field];
         }
-        finally { if (e_1) throw e_1.error; }
     }
     return filters;
 }
-//# sourceMappingURL=request.utils.js.map

package/build/esm/utils/response.utils.d.ts

@@ -160,4 +160,3 @@ export declare function createPaginatedResponse<T>(allItems: T[], page: number,
  * @param {SuccessResponse<any> | ErrorResponse | RedirectResponse} apiResponse - API response instance.
  */
 export declare function sendResponse(res: any, apiResponse: SuccessResponse<any> | ErrorResponse | RedirectResponse): void;
-//# sourceMappingURL=response.utils.d.ts.map