@expressots/core 3.0.0 → 4.0.0-preview.3

package/lib/cjs/error/exception-handler-middleware.js

@@ -0,0 +1,378 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ExceptionHandlerMiddleware = void 0;
+const exception_filter_registry_js_1 = require("./exception-filter-registry.js");
+const logger_provider_js_1 = require("../provider/logger/logger.provider.js");
+const index_js_1 = require("./index.js");
+const exception_filter_constants_js_1 = require("./exception-filter-constants.js");
+const logger_suggestions_js_1 = require("../provider/logger/logger.suggestions.js");
+/**
+ * Enhanced error handler middleware that integrates with exception filters
+ * Supports route-specific filters, exception type filters, and fallback handling
+ */
+class ExceptionHandlerMiddleware {
+    constructor(container, registry, showStackTrace = false) {
+        /**
+         * Express error handler middleware function
+         */
+        this.handle = async (error, req, res, next) => {
+            // Store error on request for flow tracking (if not already stored)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            if (!req.__expressotsFlowError) {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                req.__expressotsFlowError =
+                    error instanceof Error ? error : new Error(String(error));
+            }
+            // Build exception context
+            const context = {
+                request: req,
+                response: res,
+                next,
+                route: req.route?.path,
+                method: req.method,
+                showStackTrace: this.showStackTrace,
+            };
+            // Try to get HttpContext from request if available
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (req.httpContext) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    context.httpContext = req.httpContext;
+                }
+            }
+            catch {
+                // HttpContext not available
+            }
+            // Try to extract controller and handler from request metadata (most reliable)
+            // This is attached by the handlerFactory during handler execution
+            try {
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let controllerConstructor = req.__expressotsController;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                let methodName = req.__expressotsMethod;
+                // Fallback: Try to extract from route stack if not on request
+                if (!controllerConstructor) {
+                    const route = req.route;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    if (route && route.stack) {
+                        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                        const stack = route.stack;
+                        // Traverse the stack to find the handler with ExpressoTS metadata
+                        // The handler is typically the last layer in the stack
+                        let handler = null;
+                        for (let i = stack.length - 1; i >= 0; i--) {
+                            const layer = stack[i];
+                            if (layer && layer.handle) {
+                                const potentialHandler = layer.handle;
+                                // Check if this handler has ExpressoTS metadata
+                                if (potentialHandler && potentialHandler.__expressotsController) {
+                                    handler = potentialHandler;
+                                    break;
+                                }
+                                // If no metadata found yet, use this as fallback
+                                if (!handler) {
+                                    handler = potentialHandler;
+                                }
+                            }
+                        }
+                        if (handler) {
+                            const handlerWithMetadata = handler;
+                            controllerConstructor = handlerWithMetadata.__expressotsController;
+                            methodName = handlerWithMetadata.__expressotsMethod;
+                        }
+                    }
+                }
+                if (controllerConstructor) {
+                    // Set controller constructor (required for filter extraction)
+                    context.controller = controllerConstructor;
+                    // Extract handler method name
+                    const handlerMethodName = methodName || "unknownHandler";
+                    context.handler = handlerMethodName;
+                    // Store controller constructor for filter extraction (redundant but kept for compatibility)
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    context.__controllerConstructor = controllerConstructor;
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    context.__methodName = methodName;
+                }
+                else {
+                    // Fallback: use path-based extraction
+                    // Note: context.controller remains undefined as we don't have the constructor
+                    // The handler name is still set for logging purposes
+                    context.handler = req.route?.path || req.path || "unknownHandler";
+                }
+            }
+            catch (error) {
+                // Could not extract controller info, use path-based fallback
+                // Note: context.controller remains undefined as we don't have the constructor
+                context.handler = req.path || "unknownHandler";
+                if (this.logger) {
+                    this.logger.warn(`Could not extract controller/handler info: ${error}. Using path-based fallback.`, "exception-handler");
+                }
+            }
+            // Get route-specific filters (method-level, then controller-level)
+            const routeFilters = this.getRouteFilters(req);
+            // Get exception-type filters from registry
+            let exceptionFilters = [];
+            if (this.registry) {
+                exceptionFilters = this.registry.getFilters(error);
+            }
+            // Combine filters (route-specific first, then exception-type)
+            const allFilters = [...routeFilters, ...exceptionFilters];
+            if (allFilters.length > 0) {
+                // Execute filters
+                await this.executeFilters(allFilters, error, context);
+            }
+            else {
+                // Fallback to default handler
+                this.defaultHandler(error, context);
+            }
+        };
+        this.container = container;
+        this.registry = registry;
+        this.showStackTrace = showStackTrace;
+        if (container) {
+            try {
+                this.logger = container.get(logger_provider_js_1.Logger);
+                if (!this.registry) {
+                    // Try to get registry from container or create new one
+                    if (container.isBound(exception_filter_registry_js_1.ExceptionFilterRegistry)) {
+                        this.registry = container.get(exception_filter_registry_js_1.ExceptionFilterRegistry);
+                    }
+                    else {
+                        this.registry = new exception_filter_registry_js_1.ExceptionFilterRegistry(container, this.logger);
+                        this.registry.initialize();
+                    }
+                }
+            }
+            catch (error) {
+                // Container not available or Logger not bound - use fallback
+                console.warn("Exception filter registry not available:", error);
+            }
+        }
+    }
+    /**
+     * Get route-specific exception filters
+     * Extracts method-level filters (highest priority) and controller-level filters
+     */
+    getRouteFilters(req) {
+        const filters = [];
+        if (!this.container) {
+            return filters;
+        }
+        try {
+            // First, try to get controller and method from request metadata (most reliable)
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let controllerConstructor = req.__expressotsController;
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            let methodName = req.__expressotsMethod;
+            // Fallback: Try to extract from route stack if not on request
+            if (!controllerConstructor) {
+                const route = req.route;
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                if (route && route.stack) {
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    const stack = route.stack;
+                    // Traverse the stack to find the handler with ExpressoTS metadata
+                    // The handler is typically the last layer in the stack
+                    let handler = null;
+                    for (let i = stack.length - 1; i >= 0; i--) {
+                        const layer = stack[i];
+                        if (layer && layer.handle) {
+                            const potentialHandler = layer.handle;
+                            // Check if this handler has ExpressoTS metadata
+                            if (potentialHandler && potentialHandler.__expressotsController) {
+                                handler = potentialHandler;
+                                break;
+                            }
+                            // If no metadata found yet, use this as fallback
+                            if (!handler) {
+                                handler = potentialHandler;
+                            }
+                        }
+                    }
+                    if (handler) {
+                        const handlerWithMetadata = handler;
+                        controllerConstructor = handlerWithMetadata.__expressotsController;
+                        methodName = handlerWithMetadata.__expressotsMethod;
+                    }
+                }
+            }
+            if (controllerConstructor) {
+                // Get method-level filters (highest priority)
+                // Method filters are stored on the controller constructor with the method name as key
+                const methodFilters = Reflect.getMetadata(exception_filter_constants_js_1.EXCEPTION_FILTER_METADATA_KEY.methodExceptionFilters, controllerConstructor, methodName);
+                if (methodFilters && methodFilters.length > 0) {
+                    methodFilters.forEach((FilterClass) => {
+                        try {
+                            const filterInstance = this.instantiateFilter(FilterClass);
+                            if (filterInstance) {
+                                filters.push(filterInstance);
+                            }
+                        }
+                        catch (error) {
+                            // Could not instantiate filter
+                            if (this.logger) {
+                                this.logger.warn(`Failed to instantiate method-level filter ${FilterClass.name}: ${error}`, "exception-handler");
+                            }
+                        }
+                    });
+                }
+                // Get controller-level filters (added after method-level filters)
+                // Controller filters are stored directly on the controller constructor
+                const controllerFilters = Reflect.getMetadata(exception_filter_constants_js_1.EXCEPTION_FILTER_METADATA_KEY.controllerExceptionFilters, controllerConstructor);
+                if (controllerFilters && controllerFilters.length > 0) {
+                    controllerFilters.forEach((FilterClass) => {
+                        try {
+                            const filterInstance = this.instantiateFilter(FilterClass);
+                            if (filterInstance) {
+                                // Only add if not already added (avoid duplicates)
+                                if (!filters.some((f) => f.constructor === FilterClass)) {
+                                    filters.push(filterInstance);
+                                }
+                            }
+                        }
+                        catch (error) {
+                            // Could not instantiate filter
+                            if (this.logger) {
+                                this.logger.warn(`Failed to instantiate controller-level filter ${FilterClass.name}: ${error}`, "exception-handler");
+                            }
+                        }
+                    });
+                }
+            }
+        }
+        catch (error) {
+            // Could not extract route filters
+            if (this.logger) {
+                this.logger.warn(`Failed to extract route filters: ${error}`, "exception-handler");
+            }
+        }
+        return filters;
+    }
+    /**
+     * Instantiate an exception filter, trying container first, then direct instantiation
+     */
+    instantiateFilter(FilterClass) {
+        try {
+            if (this.container.isBound(FilterClass)) {
+                return this.container.get(FilterClass);
+            }
+            else {
+                // Try to instantiate directly
+                const instance = new FilterClass();
+                if (this.container.isBound(logger_provider_js_1.Logger) &&
+                    instance.logger === undefined) {
+                    instance.logger = this.container.get(logger_provider_js_1.Logger);
+                }
+                // Try to inject Report provider if available
+                try {
+                    if (this.container.isBound("Report") &&
+                        instance.report === undefined) {
+                        instance.report =
+                            this.container.get("Report");
+                    }
+                }
+                catch {
+                    // Report not available, skip
+                }
+                return instance;
+            }
+        }
+        catch (error) {
+            if (this.logger) {
+                this.logger.warn(`Failed to instantiate filter ${FilterClass.name}: ${error}`, "exception-handler");
+            }
+            return null;
+        }
+    }
+    /**
+     * Execute exception filters in order
+     */
+    async executeFilters(filters, exception, context) {
+        for (const filter of filters) {
+            try {
+                await filter.catch(exception, context);
+                // If filter handled the exception (response sent), stop processing
+                if (context.response.headersSent) {
+                    return;
+                }
+            }
+            catch (filterError) {
+                // Log filter error but continue to next filter
+                if (this.logger) {
+                    this.logger.error(`Exception filter ${filter.constructor.name} threw an error: ${filterError}`, "exception-handler");
+                }
+                else {
+                    console.error(`Exception filter error:`, filterError);
+                }
+            }
+        }
+        // If no filter handled it, use default
+        if (!context.response.headersSent) {
+            this.defaultHandler(exception, context);
+        }
+    }
+    /**
+     * Default error handler (fallback)
+     */
+    defaultHandler(exception, context) {
+        if (context.response.headersSent) {
+            return;
+        }
+        // Show error suggestions if enabled
+        // Get config from logger if available, otherwise use default
+        let suggestionsConfig = (0, logger_suggestions_js_1.getDefaultSuggestionsConfig)();
+        if (this.logger) {
+            try {
+                const loggerConfig = this.logger.getConfig?.();
+                if (loggerConfig?.suggestions) {
+                    suggestionsConfig = {
+                        ...suggestionsConfig,
+                        ...loggerConfig.suggestions,
+                    };
+                }
+            }
+            catch {
+                // If getConfig fails, use default config
+            }
+        }
+        if (suggestionsConfig.enabled && this.logger) {
+            const hints = (0, logger_suggestions_js_1.getErrorHints)(exception, {
+                path: context.request.path,
+                method: context.method,
+                statusCode: exception instanceof index_js_1.AppError
+                    ? exception.statusCode
+                    : index_js_1.StatusCode.InternalServerError,
+            }, suggestionsConfig);
+            if (hints.length > 0) {
+                const suggestionsText = (0, logger_suggestions_js_1.formatSuggestions)(hints);
+                this.logger.info(suggestionsText, "exception-handler");
+            }
+        }
+        if (exception instanceof index_js_1.AppError) {
+            const responseBody = {
+                code: exception.statusCode,
+                error: exception.message,
+            };
+            // Include stack trace if showStackTrace is enabled
+            if (this.showStackTrace && exception.stack) {
+                responseBody.stack = exception.stack;
+            }
+            context.response.status(exception.statusCode).json(responseBody);
+        }
+        else {
+            const responseBody = {
+                code: index_js_1.StatusCode.InternalServerError,
+                error: "An unexpected error occurred.",
+            };
+            // Include stack trace if showStackTrace is enabled
+            if (this.showStackTrace && exception.stack) {
+                responseBody.stack = exception.stack;
+            }
+            context.response
+                .status(index_js_1.StatusCode.InternalServerError)
+                .json(responseBody);
+        }
+    }
+}
+exports.ExceptionHandlerMiddleware = ExceptionHandlerMiddleware;

package/lib/cjs/error/filters/app-error.filter.js

@@ -0,0 +1,31 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AppErrorFilter = void 0;
+const app_error_js_1 = require("../app-error.js");
+const base_exception_filter_js_1 = require("../base-exception-filter.js");
+const exception_filter_decorators_js_1 = require("../exception-filter-decorators.js");
+/**
+ * Built-in exception filter for AppError instances.
+ * Not auto-registered. Bind it explicitly or use `setErrorHandler({ filters: [AppErrorFilter] })`.
+ */
+let AppErrorFilter = class AppErrorFilter extends base_exception_filter_js_1.BaseExceptionFilter {
+    catch(exception, context) {
+        this.logError(exception, context);
+        const problemDetails = exception.toProblemDetails();
+        // Set instance to request path if not provided
+        if (!problemDetails.instance) {
+            problemDetails.instance = context.request.path;
+        }
+        this.sendErrorResponse(context, exception.statusCode, problemDetails);
+    }
+};
+exports.AppErrorFilter = AppErrorFilter;
+exports.AppErrorFilter = AppErrorFilter = __decorate([
+    (0, exception_filter_decorators_js_1.Catch)(app_error_js_1.AppError)
+], AppErrorFilter);

package/lib/cjs/error/filters/global-exception.filter.js

@@ -0,0 +1,39 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GlobalExceptionFilter = void 0;
+const status_code_js_1 = require("../status-code.js");
+const base_exception_filter_js_1 = require("../base-exception-filter.js");
+const exception_filter_decorators_js_1 = require("../exception-filter-decorators.js");
+/**
+ * Global exception filter that catches all unhandled exceptions.
+ * Not auto-registered. Bind it explicitly or use `setErrorHandler({ filters: [GlobalExceptionFilter] })`.
+ */
+let GlobalExceptionFilter = class GlobalExceptionFilter extends base_exception_filter_js_1.BaseExceptionFilter {
+    catch(exception, context) {
+        this.logError(exception, context);
+        // Don't expose internal errors in production
+        const isDevelopment = process.env.NODE_ENV === "development" || process.env.NODE_ENV === "test";
+        const response = {
+            type: "https://expressots.dev/errors/internal-server-error",
+            title: isDevelopment ? exception.message : "An unexpected error occurred",
+            status: status_code_js_1.StatusCode.InternalServerError,
+            instance: context.request.path,
+            timestamp: new Date().toISOString(),
+        };
+        // Include stack trace in development mode
+        if (isDevelopment && exception.stack) {
+            response.stack = exception.stack;
+        }
+        this.sendErrorResponse(context, status_code_js_1.StatusCode.InternalServerError, response);
+    }
+};
+exports.GlobalExceptionFilter = GlobalExceptionFilter;
+exports.GlobalExceptionFilter = GlobalExceptionFilter = __decorate([
+    (0, exception_filter_decorators_js_1.Catch)()
+], GlobalExceptionFilter);

package/lib/cjs/error/filters/not-found.filter.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundFilter = void 0;
+const status_code_js_1 = require("../status-code.js");
+const base_exception_filter_js_1 = require("../base-exception-filter.js");
+const exception_filter_decorators_js_1 = require("../exception-filter-decorators.js");
+const not_found_error_js_1 = require("../not-found.error.js");
+/**
+ * Built-in exception filter for NotFoundError instances.
+ * Not auto-registered. Bind it explicitly or use `setErrorHandler({ filters: [NotFoundFilter] })`.
+ */
+let NotFoundFilter = class NotFoundFilter extends base_exception_filter_js_1.BaseExceptionFilter {
+    catch(exception, context) {
+        this.logError(exception, context);
+        const response = {
+            type: "https://expressots.dev/errors/not-found",
+            title: exception.message || "Resource not found",
+            status: status_code_js_1.StatusCode.NotFound,
+            instance: context.request.path,
+            timestamp: new Date().toISOString(),
+            ...(exception.details && { detail: exception.details }),
+        };
+        this.sendErrorResponse(context, status_code_js_1.StatusCode.NotFound, response);
+    }
+};
+exports.NotFoundFilter = NotFoundFilter;
+exports.NotFoundFilter = NotFoundFilter = __decorate([
+    (0, exception_filter_decorators_js_1.Catch)(not_found_error_js_1.NotFoundError)
+], NotFoundFilter);

package/lib/cjs/error/filters/validation-error.filter.js

@@ -0,0 +1,35 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValidationErrorFilter = void 0;
+const status_code_js_1 = require("../status-code.js");
+const base_exception_filter_js_1 = require("../base-exception-filter.js");
+const exception_filter_decorators_js_1 = require("../exception-filter-decorators.js");
+const validation_error_js_1 = require("../validation.error.js");
+/**
+ * Built-in exception filter for ValidationError instances.
+ * Not auto-registered. Bind it explicitly or use `setErrorHandler({ filters: [ValidationErrorFilter] })`.
+ */
+let ValidationErrorFilter = class ValidationErrorFilter extends base_exception_filter_js_1.BaseExceptionFilter {
+    catch(exception, context) {
+        this.logError(exception, context);
+        const response = {
+            type: "https://expressots.dev/errors/validation-failed",
+            title: "Validation Failed",
+            status: status_code_js_1.StatusCode.BadRequest,
+            instance: context.request.path,
+            timestamp: new Date().toISOString(),
+            validationErrors: exception.errors,
+        };
+        this.sendErrorResponse(context, status_code_js_1.StatusCode.BadRequest, response);
+    }
+};
+exports.ValidationErrorFilter = ValidationErrorFilter;
+exports.ValidationErrorFilter = ValidationErrorFilter = __decorate([
+    (0, exception_filter_decorators_js_1.Catch)(validation_error_js_1.ValidationError)
+], ValidationErrorFilter);

package/lib/cjs/error/index.js

@@ -1,9 +1,30 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.AppError = exports.Report = exports.StatusCode = void 0;
-var status_code_1 = require("./status-code");
-Object.defineProperty(exports, "StatusCode", { enumerable: true, get: function () { return status_code_1.StatusCode; } });
-var report_1 = require("./report");
-Object.defineProperty(exports, "Report", { enumerable: true, get: function () { return report_1.Report; } });
-var app_error_1 = require("./app-error");
-Object.defineProperty(exports, "AppError", { enumerable: true, get: function () { return app_error_1.AppError; } });
+exports.ValidationErrorFilter = exports.NotFoundFilter = exports.GlobalExceptionFilter = exports.AppErrorFilter = exports.EXCEPTION_FILTER_METADATA_KEY = exports.UseFilters = exports.Catch = exports.ExceptionFilterRegistry = exports.BaseExceptionFilter = exports.ValidationErrorClass = exports.NotFoundError = exports.AppError = exports.Report = exports.StatusCode = void 0;
+var status_code_js_1 = require("./status-code.js");
+Object.defineProperty(exports, "StatusCode", { enumerable: true, get: function () { return status_code_js_1.StatusCode; } });
+var report_js_1 = require("./report.js");
+Object.defineProperty(exports, "Report", { enumerable: true, get: function () { return report_js_1.Report; } });
+var app_error_js_1 = require("./app-error.js");
+Object.defineProperty(exports, "AppError", { enumerable: true, get: function () { return app_error_js_1.AppError; } });
+var not_found_error_js_1 = require("./not-found.error.js");
+Object.defineProperty(exports, "NotFoundError", { enumerable: true, get: function () { return not_found_error_js_1.NotFoundError; } });
+var validation_error_js_1 = require("./validation.error.js");
+Object.defineProperty(exports, "ValidationErrorClass", { enumerable: true, get: function () { return validation_error_js_1.ValidationError; } });
+var base_exception_filter_js_1 = require("./base-exception-filter.js");
+Object.defineProperty(exports, "BaseExceptionFilter", { enumerable: true, get: function () { return base_exception_filter_js_1.BaseExceptionFilter; } });
+var exception_filter_registry_js_1 = require("./exception-filter-registry.js");
+Object.defineProperty(exports, "ExceptionFilterRegistry", { enumerable: true, get: function () { return exception_filter_registry_js_1.ExceptionFilterRegistry; } });
+var exception_filter_decorators_js_1 = require("./exception-filter-decorators.js");
+Object.defineProperty(exports, "Catch", { enumerable: true, get: function () { return exception_filter_decorators_js_1.Catch; } });
+Object.defineProperty(exports, "UseFilters", { enumerable: true, get: function () { return exception_filter_decorators_js_1.UseFilters; } });
+var exception_filter_constants_js_1 = require("./exception-filter-constants.js");
+Object.defineProperty(exports, "EXCEPTION_FILTER_METADATA_KEY", { enumerable: true, get: function () { return exception_filter_constants_js_1.EXCEPTION_FILTER_METADATA_KEY; } });
+var app_error_filter_js_1 = require("./filters/app-error.filter.js");
+Object.defineProperty(exports, "AppErrorFilter", { enumerable: true, get: function () { return app_error_filter_js_1.AppErrorFilter; } });
+var global_exception_filter_js_1 = require("./filters/global-exception.filter.js");
+Object.defineProperty(exports, "GlobalExceptionFilter", { enumerable: true, get: function () { return global_exception_filter_js_1.GlobalExceptionFilter; } });
+var not_found_filter_js_1 = require("./filters/not-found.filter.js");
+Object.defineProperty(exports, "NotFoundFilter", { enumerable: true, get: function () { return not_found_filter_js_1.NotFoundFilter; } });
+var validation_error_filter_js_1 = require("./filters/validation-error.filter.js");
+Object.defineProperty(exports, "ValidationErrorFilter", { enumerable: true, get: function () { return validation_error_filter_js_1.ValidationErrorFilter; } });

package/lib/cjs/error/not-found.error.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotFoundError = void 0;
+const app_error_js_1 = require("./app-error.js");
+const status_code_js_1 = require("./status-code.js");
+/**
+ * NotFoundError - Specific error type for resource not found scenarios
+ */
+class NotFoundError extends app_error_js_1.AppError {
+    constructor(resource, id) {
+        super(`${resource}${id ? ` with id ${id}` : ""} not found`, status_code_js_1.StatusCode.NotFound, undefined, {
+            type: "https://expressots.dev/errors/not-found",
+            details: { resource, id },
+        });
+    }
+}
+exports.NotFoundError = NotFoundError;