@expressots/adapter-express 3.0.0-beta.4.2 → 4.0.0-preview.1

package/lib/cjs/adapter-express/express-utils/guard-context-factory.js

@@ -0,0 +1,84 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardContextFactory = void 0;
+require("reflect-metadata");
+const core_1 = require("@expressots/core");
+const http_context_store_js_1 = require("./http-context-store.js");
+/**
+ * Factory for creating GuardContext from Express request/response
+ */
+let GuardContextFactory = class GuardContextFactory {
+    constructor(container, scopeExtractor) {
+        this.container = container;
+        this.scopeExtractor = scopeExtractor;
+    }
+    /**
+     * Create GuardContext from Express request/response
+     */
+    async create(req, res) {
+        // Get HttpContext (created by InversifyExpressServer's first middleware
+        // and stored in a per-request WeakMap; see http-context-store.ts).
+        const httpContext = (0, http_context_store_js_1.getHttpContext)(req);
+        if (!httpContext) {
+            throw new Error("HttpContext not found on request. Ensure InversifyExpressServer is properly configured.");
+        }
+        // Extract scope information
+        const scope = await this.scopeExtractor.extract(req);
+        // Extract route metadata
+        const route = {
+            controller: 
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            req.__expressotsControllerName || "unknown",
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            method: req.__expressotsMethod || "unknown",
+            path: req.path,
+            params: req.params,
+            query: req.query,
+        };
+        // Create guard context
+        // Note: httpContext.user is Principal from adapter-express, but GuardContext expects Principal from core
+        // They have the same structure, so this is compatible
+        // Note: httpContext.container is inversifyInterfaces.Container, but GuardContext expects Container from core
+        // They are compatible, so we cast it
+        const context = {
+            request: req,
+            response: res,
+            principal: httpContext.user, // Cast to core Principal type (same structure)
+            container: httpContext.container, // Request-scoped child container!
+            scope,
+            route,
+            getScoped: (identifier, scopeName) => {
+                // Resolve with scope awareness
+                // Note: scopeName is optional and can be used for custom scopes (e.g., tenant)
+                if (scopeName) {
+                    // For custom scopes, use named binding or scope registry
+                    // For now, fallback to regular get (can be enhanced later)
+                    return httpContext.container.get(identifier);
+                }
+                return httpContext.container.get(identifier);
+            },
+            getTenantId: () => scope.tenant,
+            getRequestId: () => scope.request,
+        };
+        return context;
+    }
+};
+exports.GuardContextFactory = GuardContextFactory;
+exports.GuardContextFactory = GuardContextFactory = __decorate([
+    (0, core_1.injectable)(),
+    __param(0, (0, core_1.inject)(core_1.Container)),
+    __param(1, (0, core_1.inject)("IScopeExtractor")),
+    __metadata("design:paramtypes", [Object, Object])
+], GuardContextFactory);

package/lib/cjs/adapter-express/express-utils/guard-middleware.js

@@ -0,0 +1,115 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GuardMiddleware = void 0;
+const core_1 = require("@expressots/core");
+const core_2 = require("@expressots/core");
+const guard_context_factory_js_1 = require("./guard-context-factory.js");
+const core_3 = require("@expressots/core");
+/**
+ * Express middleware that executes guards before route handler
+ */
+let GuardMiddleware = class GuardMiddleware {
+    constructor(executor, contextFactory, container) {
+        this.executor = executor;
+        this.contextFactory = contextFactory;
+        this.container = container;
+        /**
+         * Express middleware function
+         */
+        this.execute = async (req, res, next) => {
+            // Get request ID for flow tracking
+            const requestContext = core_1.ContextManager.getCurrentContext();
+            const requestId = requestContext?.requestId;
+            const flowTracker = requestId ? (0, core_1.findFlowTracker)(requestId) : undefined;
+            // Extract guards from route metadata (controller + method level)
+            const guards = this.extractGuards(req);
+            if (guards.length === 0) {
+                return next(); // No guards, proceed
+            }
+            // Start tracking guard execution
+            const guardNames = guards.map((g) => {
+                if (typeof g === "function") {
+                    return g.name || "UnknownGuard";
+                }
+                return g.constructor.name;
+            });
+            const guardStepName = `Guards: ${guardNames.join(", ")}`;
+            if (flowTracker?.isEnabled()) {
+                flowTracker.startStep("guard", guardStepName, {
+                    guardCount: guards.length,
+                    guardNames,
+                });
+            }
+            try {
+                // Create guard context
+                const context = await this.contextFactory.create(req, res);
+                // Execute guards
+                const result = await this.executor.execute(guards, context);
+                if (!result.allowed) {
+                    // End guard step with failure
+                    if (flowTracker?.isEnabled()) {
+                        flowTracker.failStep(result.error);
+                    }
+                    // Throw error to be caught by exception handler
+                    throw result.error || core_3.AppError.forbidden("Access denied");
+                }
+                // End guard step with success
+                if (flowTracker?.isEnabled()) {
+                    flowTracker.endStep("success");
+                }
+                next();
+            }
+            catch (error) {
+                // Store error on request for flow tracking
+                // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                req.__expressotsFlowError =
+                    error instanceof Error ? error : new Error(String(error));
+                // End guard step with failure if not already ended
+                if (flowTracker?.isEnabled()) {
+                    const currentFlow = flowTracker.getFlow();
+                    const lastStep = currentFlow.steps[currentFlow.steps.length - 1];
+                    if (lastStep && lastStep.name === guardStepName && lastStep.status === "success") {
+                        // Step was already ended, don't end again
+                    }
+                    else {
+                        flowTracker.failStep(error instanceof Error ? error : undefined);
+                    }
+                }
+                next(error);
+            }
+        };
+    }
+    /**
+     * Extract guards from request metadata
+     * @private
+     */
+    extractGuards(req) {
+        // Extract from request metadata (set during route registration)
+        const reqWithGuards = req;
+        const controllerGuards = reqWithGuards.__expressotsControllerGuards || [];
+        const methodGuards = reqWithGuards.__expressotsMethodGuards || [];
+        return [...controllerGuards, ...methodGuards];
+    }
+};
+exports.GuardMiddleware = GuardMiddleware;
+exports.GuardMiddleware = GuardMiddleware = __decorate([
+    (0, core_1.injectable)(),
+    __param(0, (0, core_1.inject)(core_2.GuardExecutor)),
+    __param(1, (0, core_1.inject)(guard_context_factory_js_1.GuardContextFactory)),
+    __param(2, (0, core_1.inject)(core_1.Container)),
+    __metadata("design:paramtypes", [core_2.GuardExecutor,
+        guard_context_factory_js_1.GuardContextFactory,
+        core_1.Container])
+], GuardMiddleware);

package/lib/cjs/adapter-express/express-utils/guard-utils.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getControllerGuards = getControllerGuards;
+exports.getMethodGuards = getMethodGuards;
+require("reflect-metadata");
+const core_1 = require("@expressots/core");
+/**
+ * Extract guards from controller metadata
+ */
+function getControllerGuards(constructor) {
+    return (Reflect.getMetadata(core_1.GUARD_METADATA_KEY.controllerGuards, constructor) || []);
+}
+/**
+ * Extract guards from method metadata
+ */
+function getMethodGuards(constructor, methodName) {
+    return (Reflect.getMetadata(core_1.GUARD_METADATA_KEY.methodGuards, constructor, methodName) || []);
+}

package/lib/cjs/adapter-express/express-utils/http-context-store.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setHttpContext = setHttpContext;
+exports.getHttpContext = getHttpContext;
+exports.hasHttpContext = hasHttpContext;
+const httpContextByRequest = new WeakMap();
+function setHttpContext(req, ctx) {
+    httpContextByRequest.set(req, ctx);
+}
+function getHttpContext(req) {
+    return httpContextByRequest.get(req);
+}
+function hasHttpContext(req) {
+    return httpContextByRequest.has(req);
+}

package/lib/cjs/adapter-express/express-utils/http-status-middleware.js

@@ -3,7 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpStatusCodeMiddleware = void 0;
 require("reflect-metadata");
 const core_1 = require("@expressots/core");
-const constants_1 = require("./constants");
+const constants_js_1 = require("./constants.js");
 /**
  * Middleware that applies the status code to the response.
  * @returns express.RequestHandler
@@ -14,7 +14,7 @@ class HttpStatusCodeMiddleware extends core_1.ExpressoMiddleware {
         this.globalPrefix = globalPrefix;
     }
     use(req, res, next) {
-        const statusCodeMapping = Reflect.getMetadata(constants_1.HTTP_CODE_METADATA.httpCode, Reflect);
+        const statusCodeMapping = Reflect.getMetadata(constants_js_1.HTTP_CODE_METADATA.httpCode, Reflect);
         let path = req.path;
         if (this.globalPrefix !== "/" && path.startsWith(this.globalPrefix)) {
             path = path.slice(this.globalPrefix.length);
@@ -23,18 +23,53 @@ class HttpStatusCodeMiddleware extends core_1.ExpressoMiddleware {
         const formattedMethod = req.method.toLowerCase();
         path = `${path || "/"}/-${formattedMethod}`;
         const statusCode = statusCodeMapping[path];
+        let explicitStatus = null;
         if (statusCode) {
             res.status(statusCode);
+            explicitStatus = statusCode;
         }
         else {
             const patternMatchStatusCode = this.findMatchingParameterPath(path, statusCodeMapping);
             if (patternMatchStatusCode) {
                 res.status(patternMatchStatusCode);
+                explicitStatus = patternMatchStatusCode;
             }
             else {
                 this.setDefaultStatusCode(req, res);
             }
         }
+        /**
+         * When @Http(...) declares an explicit status, honor it even when the
+         * client sent conditional headers (If-None-Match / If-Modified-Since).
+         *
+         * Without this, Express's `res.send()` evaluates `req.fresh` (which is
+         * `true` for any 2xx status whose ETag matches the request's
+         * If-None-Match) and silently rewrites our 201/202/206/etc. into 304
+         * Not Modified. That makes @Http() unreliable in any caching
+         * environment — including a developer hitting refresh in their
+         * browser. We override `req.fresh` to always return `false` for this
+         * one response so the explicit status wins.
+         *
+         * For the 200 default we leave Express's freshness behavior alone, so
+         * normal GET caching still works as expected.
+         */
+        if (explicitStatus !== null && explicitStatus !== 200) {
+            try {
+                Object.defineProperty(req, "fresh", {
+                    configurable: true,
+                    enumerable: true,
+                    get: () => false,
+                });
+            }
+            catch {
+                // Some proxied / decorated request objects make this property
+                // non-configurable. In that case we fall back to stripping the
+                // conditional headers entirely, which has the same effect on
+                // Express's freshness check.
+                delete req.headers["if-none-match"];
+                delete req.headers["if-modified-since"];
+            }
+        }
         next();
     }
     /**

package/lib/cjs/adapter-express/express-utils/index.js

@@ -14,4 +14,70 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./decorators"), exports);
+exports.hasHttpContext = exports.getHttpContext = exports.ValidationService = exports.hasValidationMetadata = exports.getValidationMetadata = exports.Validate = exports.validatedHeaders = exports.validatedParam = exports.validatedQuery = exports.validatedBody = exports.createRouteMappings = exports.createLazyModuleMiddleware = exports.setupLazyLoadingForExpress = exports.setupInterceptorsForExpress = exports.setupEventSystemForExpress = exports.setupAuthorizationForExpress = exports.TYPE = exports.PermissionPreloaderMiddleware = exports.ScopeExtractor = exports.createInterceptorMiddleware = exports.InterceptorMiddleware = exports.GuardMiddleware = exports.GuardContextFactory = exports.getMethodGuards = exports.getControllerGuards = exports.UseFilters = exports.Catch = exports.isComposedMiddleware = exports.sequence = exports.combine = exports.isConditionalMiddleware = exports.unless = exports.when = exports.pattern = exports.Patterns = exports.StreamResponse = exports.YamlOptions = exports.XmlOptions = exports.CsvOptions = exports.Produces = exports.Consumes = exports.Accept = void 0;
+__exportStar(require("./decorators.js"), exports);
+var content_negotiation_decorators_js_1 = require("./content-negotiation-decorators.js");
+Object.defineProperty(exports, "Accept", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.Accept; } });
+Object.defineProperty(exports, "Consumes", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.Consumes; } });
+Object.defineProperty(exports, "Produces", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.Produces; } });
+Object.defineProperty(exports, "CsvOptions", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.CsvOptions; } });
+Object.defineProperty(exports, "XmlOptions", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.XmlOptions; } });
+Object.defineProperty(exports, "YamlOptions", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.YamlOptions; } });
+Object.defineProperty(exports, "StreamResponse", { enumerable: true, get: function () { return content_negotiation_decorators_js_1.StreamResponse; } });
+var route_constraints_js_1 = require("./route-constraints.js");
+Object.defineProperty(exports, "Patterns", { enumerable: true, get: function () { return route_constraints_js_1.Patterns; } });
+Object.defineProperty(exports, "pattern", { enumerable: true, get: function () { return route_constraints_js_1.pattern; } });
+var conditional_middleware_js_1 = require("./conditional-middleware.js");
+Object.defineProperty(exports, "when", { enumerable: true, get: function () { return conditional_middleware_js_1.when; } });
+Object.defineProperty(exports, "unless", { enumerable: true, get: function () { return conditional_middleware_js_1.unless; } });
+Object.defineProperty(exports, "isConditionalMiddleware", { enumerable: true, get: function () { return conditional_middleware_js_1.isConditionalMiddleware; } });
+var middleware_composition_js_1 = require("./middleware-composition.js");
+Object.defineProperty(exports, "combine", { enumerable: true, get: function () { return middleware_composition_js_1.combine; } });
+Object.defineProperty(exports, "sequence", { enumerable: true, get: function () { return middleware_composition_js_1.sequence; } });
+Object.defineProperty(exports, "isComposedMiddleware", { enumerable: true, get: function () { return middleware_composition_js_1.isComposedMiddleware; } });
+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 guard_utils_js_1 = require("./guard-utils.js");
+Object.defineProperty(exports, "getControllerGuards", { enumerable: true, get: function () { return guard_utils_js_1.getControllerGuards; } });
+Object.defineProperty(exports, "getMethodGuards", { enumerable: true, get: function () { return guard_utils_js_1.getMethodGuards; } });
+var guard_context_factory_js_1 = require("./guard-context-factory.js");
+Object.defineProperty(exports, "GuardContextFactory", { enumerable: true, get: function () { return guard_context_factory_js_1.GuardContextFactory; } });
+var guard_middleware_js_1 = require("./guard-middleware.js");
+Object.defineProperty(exports, "GuardMiddleware", { enumerable: true, get: function () { return guard_middleware_js_1.GuardMiddleware; } });
+var interceptor_middleware_js_1 = require("./interceptor-middleware.js");
+Object.defineProperty(exports, "InterceptorMiddleware", { enumerable: true, get: function () { return interceptor_middleware_js_1.InterceptorMiddleware; } });
+Object.defineProperty(exports, "createInterceptorMiddleware", { enumerable: true, get: function () { return interceptor_middleware_js_1.createInterceptorMiddleware; } });
+var scope_extractor_js_1 = require("./scope-extractor.js");
+Object.defineProperty(exports, "ScopeExtractor", { enumerable: true, get: function () { return scope_extractor_js_1.ScopeExtractor; } });
+var permission_preloader_middleware_js_1 = require("./permission-preloader.middleware.js");
+Object.defineProperty(exports, "PermissionPreloaderMiddleware", { enumerable: true, get: function () { return permission_preloader_middleware_js_1.PermissionPreloaderMiddleware; } });
+var constants_js_1 = require("./constants.js");
+Object.defineProperty(exports, "TYPE", { enumerable: true, get: function () { return constants_js_1.TYPE; } });
+var setup_authorization_js_1 = require("./setup-authorization.js");
+Object.defineProperty(exports, "setupAuthorizationForExpress", { enumerable: true, get: function () { return setup_authorization_js_1.setupAuthorizationForExpress; } });
+var setup_event_system_js_1 = require("./setup-event-system.js");
+Object.defineProperty(exports, "setupEventSystemForExpress", { enumerable: true, get: function () { return setup_event_system_js_1.setupEventSystemForExpress; } });
+var setup_interceptors_js_1 = require("./setup-interceptors.js");
+Object.defineProperty(exports, "setupInterceptorsForExpress", { enumerable: true, get: function () { return setup_interceptors_js_1.setupInterceptorsForExpress; } });
+var setup_lazy_loading_js_1 = require("./setup-lazy-loading.js");
+Object.defineProperty(exports, "setupLazyLoadingForExpress", { enumerable: true, get: function () { return setup_lazy_loading_js_1.setupLazyLoadingForExpress; } });
+var lazy_module_middleware_js_1 = require("./lazy-module-middleware.js");
+Object.defineProperty(exports, "createLazyModuleMiddleware", { enumerable: true, get: function () { return lazy_module_middleware_js_1.createLazyModuleMiddleware; } });
+Object.defineProperty(exports, "createRouteMappings", { enumerable: true, get: function () { return lazy_module_middleware_js_1.createRouteMappings; } });
+// Validation decorators
+var validation_decorators_js_1 = require("./validation-decorators.js");
+Object.defineProperty(exports, "validatedBody", { enumerable: true, get: function () { return validation_decorators_js_1.validatedBody; } });
+Object.defineProperty(exports, "validatedQuery", { enumerable: true, get: function () { return validation_decorators_js_1.validatedQuery; } });
+Object.defineProperty(exports, "validatedParam", { enumerable: true, get: function () { return validation_decorators_js_1.validatedParam; } });
+Object.defineProperty(exports, "validatedHeaders", { enumerable: true, get: function () { return validation_decorators_js_1.validatedHeaders; } });
+Object.defineProperty(exports, "Validate", { enumerable: true, get: function () { return validation_decorators_js_1.Validate; } });
+Object.defineProperty(exports, "getValidationMetadata", { enumerable: true, get: function () { return validation_decorators_js_1.getValidationMetadata; } });
+Object.defineProperty(exports, "hasValidationMetadata", { enumerable: true, get: function () { return validation_decorators_js_1.hasValidationMetadata; } });
+// Validation service
+var validation_service_js_1 = require("./validation-service.js");
+Object.defineProperty(exports, "ValidationService", { enumerable: true, get: function () { return validation_service_js_1.ValidationService; } });
+// Per-request HttpContext (replaces reflect-metadata for hot path)
+var http_context_store_js_1 = require("./http-context-store.js");
+Object.defineProperty(exports, "getHttpContext", { enumerable: true, get: function () { return http_context_store_js_1.getHttpContext; } });
+Object.defineProperty(exports, "hasHttpContext", { enumerable: true, get: function () { return http_context_store_js_1.hasHttpContext; } });

package/lib/cjs/adapter-express/express-utils/interceptor-middleware.js

@@ -0,0 +1,132 @@
+"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;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InterceptorMiddleware = void 0;
+exports.createInterceptorMiddleware = createInterceptorMiddleware;
+const core_1 = require("@expressots/core");
+const core_2 = require("@expressots/core");
+require("reflect-metadata");
+/**
+ * Express middleware that executes interceptors around route handler
+ *
+ * @layer internal
+ * @audience framework-developers
+ *
+ * @summary Quick Start
+ * InterceptorMiddleware integrates the interceptor system with Express.
+ * It wraps the route handler with interceptors defined via @UseInterceptors().
+ *
+ * @internal
+ */
+let InterceptorMiddleware = class InterceptorMiddleware {
+    constructor(executor, container) {
+        this.executor = executor;
+        this.container = container;
+    }
+    /**
+     * Create middleware for a specific controller and method
+     * @param controllerClass - Controller class
+     * @param methodName - Method name
+     * @param handler - Original route handler
+     */
+    createMiddleware(controllerClass, methodName, handler) {
+        return async (req, res, next) => {
+            // Get request ID for flow tracking
+            const requestContext = core_1.ContextManager.getCurrentContext();
+            const requestId = requestContext?.requestId;
+            const flowTracker = requestId ? (0, core_1.findFlowTracker)(requestId) : undefined;
+            // Extract interceptors from metadata
+            const interceptors = this.extractInterceptors(controllerClass, methodName);
+            if (interceptors.length === 0) {
+                // No interceptors, proceed directly
+                return handler(req, res, next)
+                    .then(() => { })
+                    .catch(next);
+            }
+            // Get interceptor names for tracking
+            const interceptorNames = interceptors.map((i) => {
+                if (typeof i === "function") {
+                    return i.name || "UnknownInterceptor";
+                }
+                return i.constructor.name;
+            });
+            const interceptorStepName = `Interceptors: ${interceptorNames.join(", ")}`;
+            // Start tracking interceptor execution (using "middleware" type as interceptors are part of request pipeline)
+            if (flowTracker?.isEnabled()) {
+                flowTracker.startStep("middleware", interceptorStepName, {
+                    interceptorCount: interceptors.length,
+                    interceptorNames,
+                });
+            }
+            try {
+                // Create execution context
+                const context = (0, core_1.createExecutionContext)(req, res, this.container, controllerClass, String(methodName));
+                // Execute interceptors with handler
+                const result = await this.executor.execute(interceptors, context, async () => {
+                    // This is the actual handler execution
+                    const handlerResult = await handler(req, res, next);
+                    return handlerResult;
+                });
+                // End interceptor step with success
+                if (flowTracker?.isEnabled()) {
+                    flowTracker.endStep("success");
+                }
+                // If handler hasn't sent response and we have a result, set it
+                if (!res.headersSent && result !== undefined) {
+                    // Store result for response handling
+                    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+                    req.__expressotsInterceptorResult = result;
+                }
+            }
+            catch (error) {
+                // End interceptor step with failure
+                if (flowTracker?.isEnabled()) {
+                    flowTracker.failStep(error instanceof Error ? error : undefined);
+                }
+                next(error);
+            }
+        };
+    }
+    /**
+     * Extract interceptors from controller and method metadata
+     * @private
+     */
+    extractInterceptors(controllerClass, methodName) {
+        // Get controller-level interceptors
+        const controllerInterceptors = Reflect.getMetadata(core_2.INTERCEPTOR_METADATA_KEY.controllerInterceptors, controllerClass) || [];
+        // Get method-level interceptors
+        const methodInterceptors = Reflect.getMetadata(core_2.INTERCEPTOR_METADATA_KEY.methodInterceptors, controllerClass, methodName) || [];
+        // Combine: controller + method level
+        return [...controllerInterceptors, ...methodInterceptors];
+    }
+};
+exports.InterceptorMiddleware = InterceptorMiddleware;
+exports.InterceptorMiddleware = InterceptorMiddleware = __decorate([
+    (0, core_1.injectable)(),
+    __param(0, (0, core_1.inject)(core_1.InterceptorExecutor)),
+    __param(1, (0, core_1.inject)(core_1.Container)),
+    __metadata("design:paramtypes", [core_1.InterceptorExecutor,
+        core_1.Container])
+], InterceptorMiddleware);
+/**
+ * Factory function to create interceptor middleware
+ * @param container - DI container
+ * @param controllerClass - Controller class
+ * @param methodName - Method name
+ * @param handler - Original handler
+ */
+function createInterceptorMiddleware(container, controllerClass, methodName, handler) {
+    const middleware = container.get(InterceptorMiddleware);
+    return middleware.createMiddleware(controllerClass, methodName, handler);
+}