exisjs 0.7.5 → 0.7.7

package/dist/router/route-scanner.js

@@ -36,10 +36,10 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.RouteScanner = void 0;
 const router_1 = require("../router/router");
 const middleware_1 = require("../middleware/middleware");
-const index_1 = require("../validator/index");
+const path = __importStar(require("node:path"));
 const node_url_1 = require("node:url");
-const context_1 = require("../server/context");
-const error_overlay_1 = require("../dev/error-overlay");
+const overlay_1 = require("../error/overlay");
+const scanner_1 = require("./scanner");
 class RouteScanner {
     constructor(app) {
         this.app = app;
@@ -50,17 +50,17 @@ class RouteScanner {
         this.globalParadigm = null;
     }
     async loadAllRoutes() {
-        for (const [filePath, entry] of this.lazyRoutes.entries()) {
+        for (const [, entry] of this.lazyRoutes.entries()) {
             if (!entry.loaded) {
                 entry.loaded = true;
-                this.app.getRouter().removeRoutesBySource('lazy:' + filePath);
-                const routePath = this.routeMap.get(filePath);
+                this.app.getRouter().removeRoutesBySource('lazy:' + entry.filePath);
+                const routePath = this.routeMap.get(entry.filePath);
                 if (routePath) {
                     try {
-                        await this.mountRouteFile(filePath, routePath);
+                        await this.mountRouteFile(entry.filePath, routePath);
                     }
                     catch (e) {
-                        this.app.log.error({ err: e, file: filePath }, 'Failed to eager-load route');
+                        this.app.log.error({ err: e, file: entry.filePath }, 'Failed to eager-load route');
                     }
                 }
             }
@@ -80,6 +80,8 @@ class RouteScanner {
         }
         // Try to load the pre-built manifest first (O(1) boot)
         let manifest = undefined;
+        let manifestErrorHandler = undefined;
+        let manifestCronJobs = undefined;
         // STANDALONE MODE: If the bundler statically injected the manifest, skip filesystem!
         if (globalThis.__EXIS_STANDALONE_MANIFEST__) {
             manifest = globalThis.__EXIS_STANDALONE_MANIFEST__;
@@ -101,6 +103,8 @@ class RouteScanner {
                         mod = await dynamicImport(url);
                     }
                     manifest = mod.manifest;
+                    manifestErrorHandler = mod.errorHandler;
+                    manifestCronJobs = mod.cronJobs;
                 }
             }
             catch (err) {
@@ -112,13 +116,25 @@ class RouteScanner {
         const searchDirs = isProd
             ? [
                 path.join(root, '.exis', 'server', 'src', 'http'),
-                path.join(root, 'dist', 'src', 'http'),
                 path.join(root, 'src', 'http'),
             ]
             : [path.join(root, 'src', 'http')];
         if (Array.isArray(manifest)) {
-            for (const dir of searchDirs) {
-                await this.mountErrorHandler(dir);
+            if (manifestErrorHandler !== undefined) {
+                if (manifestErrorHandler) {
+                    this.mountErrorHandlerFromModule(manifestErrorHandler, 'manifest:error');
+                }
+            }
+            else {
+                for (const dir of searchDirs) {
+                    await this.mountErrorHandler(dir);
+                }
+            }
+            if (Array.isArray(manifestCronJobs)) {
+                this.mountCronJobsFromEntries(manifestCronJobs);
+            }
+            else {
+                await this.mountCronJobs(root);
             }
             for (const entry of manifest) {
                 const { routePath, module: routeMod, filePath } = entry;
@@ -178,25 +194,20 @@ class RouteScanner {
                 /* ignore */
             }
         }
-        if (appDirs.length === 0)
+        if (appDirs.length === 0) {
+            await this.mountCronJobs(root);
             return;
-        this.apiDir = appDirs[0] // keep property name for backwards compatibility
-        ;
+        }
+        this.apiDir = appDirs[0]; // keep property name for backwards compatibility
         this._allApiDirs = appDirs;
         for (const appDir of appDirs) {
             await this.mountErrorHandler(appDir);
             const routes = await this.scanDirectory(appDir);
             for (const { filePath, routePath } of routes) {
-                const isBoundaryFile = filePath.endsWith('boundary.ts') ||
-                    filePath.endsWith('boundary.js') ||
-                    /\.boundary\.[jt]s$/.test(filePath);
-                if (isBoundaryFile) {
+                if ((0, scanner_1.isBoundaryFile)(filePath)) {
                     this.hasBoundaries = true;
                 }
-                const isRouteFile = filePath.endsWith('route.ts') ||
-                    filePath.endsWith('route.js') ||
-                    /\.route\.[jt]s$/.test(filePath);
-                if (isRouteFile) {
+                if ((0, scanner_1.isRouteFile)(filePath)) {
                     const normalized = path.resolve(filePath);
                     this.routeMap.set(normalized, routePath);
                     if (isDev) {
@@ -214,7 +225,7 @@ class RouteScanner {
                                     await this.mountRouteFile(normalized, routePath);
                                 }
                                 catch (err) {
-                                    (0, error_overlay_1.formatDevError)(err, normalized);
+                                    (0, overlay_1.formatDevError)(err, normalized);
                                     return;
                                 }
                                 await this.app.getRouter().handle(req, res, next);
@@ -242,6 +253,7 @@ class RouteScanner {
                 }
             }
         }
+        await this.mountCronJobs(root);
         // ─── Eager Paradigm Validation ──────────────────────────────────────────────
         // Even in dev mode (lazy routes), pre-scan all route files at startup to
         // detect mixed paradigms (OOP + functional) and throw a fatal error immediately.
@@ -293,6 +305,14 @@ class RouteScanner {
         if (!this.hasBoundaries && !isProd) {
             this.app.log.warn('No boundary.ts found — applying default security headers.');
         }
+        const docsConfig = this.app.options.docs || this.app.options.swagger;
+        if (docsConfig &&
+            (typeof docsConfig === 'boolean'
+                ? docsConfig
+                : docsConfig.enabled !== false)) {
+            const { mountDocumentation } = await Promise.resolve().then(() => __importStar(require('../swagger/mounter.js')));
+            mountDocumentation(this.app, typeof docsConfig === 'object' ? docsConfig : {});
+        }
     }
     // ─── Route File Mounting (shared by autoMount and HotReloader) ──────────────
     async mountRouteFile(filePath, routePath) {
@@ -313,461 +333,13 @@ class RouteScanner {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
             mod = require(filePath);
         }
-        const path = await Promise.resolve().then(() => __importStar(require('node:path')));
-        const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
-        const dirname = path.dirname(filePath);
-        const apiDir = this.apiDir || dirname;
-        const normDirname = path.resolve(dirname).replace(/\\/g, '/').toLowerCase();
-        const normApiDir = path.resolve(apiDir).replace(/\\/g, '/').toLowerCase();
-        const segments = normDirname.startsWith(normApiDir)
-            ? normDirname.slice(normApiDir.length).split('/').filter(Boolean)
-            : [];
-        const allMiddlewares = [];
-        const allFilters = [];
-        const allGuards = [];
-        const allInterceptors = [];
-        let allMetadata = {};
-        let allCors = undefined;
-        let allHeaders = {};
-        const activeBoundaries = [];
-        const dirsToCheck = [apiDir];
-        let tempDir = apiDir;
-        for (const segment of segments) {
-            tempDir = path.join(tempDir, segment);
-            dirsToCheck.push(tempDir);
-        }
-        for (const dir of dirsToCheck) {
-            try {
-                // Detect deprecated gateway.ts / gateway.js
-                const gatewayPathTs = path.join(dir, 'gateway.ts');
-                const gatewayPathJs = path.join(dir, 'gateway.js');
-                if ((await fs.stat(gatewayPathTs).catch(() => null)) ||
-                    (await fs.stat(gatewayPathJs).catch(() => null))) {
-                    this.app.log.warn(`Found deprecated 'gateway' file in '${dir}'. Gateways have been renamed to 'boundary.ts' in ExisJS v0.7+. Please rename it to boundary.ts.`);
-                }
-                const boundaryPathTs = path.join(dir, 'boundary.ts');
-                const boundaryPathJs = path.join(dir, 'boundary.js');
-                let targetBoundary = '';
-                if (await fs.stat(boundaryPathTs).catch(() => null))
-                    targetBoundary = boundaryPathTs;
-                else if (await fs.stat(boundaryPathJs).catch(() => null))
-                    targetBoundary = boundaryPathJs;
-                else {
-                    // Check for named boundaries like user.boundary.ts
-                    const dirFiles = await fs.readdir(dir).catch(() => []);
-                    const namedBoundary = dirFiles.find((f) => /\.boundary\.[jt]s$/.test(f));
-                    if (namedBoundary) {
-                        targetBoundary = path.join(dir, namedBoundary);
-                    }
-                }
-                if (targetBoundary) {
-                    activeBoundaries.push(targetBoundary);
-                    this.hasBoundaries = true;
-                    const boundaryUrl = process.env.VITEST || process.env.NODE_ENV === 'test'
-                        ? (0, node_url_1.pathToFileURL)(targetBoundary).href
-                        : (0, node_url_1.pathToFileURL)(targetBoundary).href + '?t=' + Date.now();
-                    let boundaryMod;
-                    try {
-                        if (process.env.VITEST || process.env.NODE_ENV === 'test') {
-                            boundaryMod = await Promise.resolve(`${boundaryUrl}`).then(s => __importStar(require(s)));
-                        }
-                        else {
-                            const dynamicImportBoundary = new Function('specifier', 'return import(specifier)');
-                            boundaryMod = await dynamicImportBoundary(boundaryUrl);
-                        }
-                    }
-                    catch {
-                        // eslint-disable-next-line @typescript-eslint/no-require-imports
-                        boundaryMod = require(targetBoundary);
-                    }
-                    // Extract config: check boundaryMod.config, boundaryMod.default, or boundaryMod itself
-                    let boundaryConfig = null;
-                    const BOUNDARY_CONFIG = Symbol.for('exisjs:boundary_config');
-                    const boundaryDefault = boundaryMod && boundaryMod.default && boundaryMod.default.default
-                        ? boundaryMod.default.default
-                        : boundaryMod && boundaryMod.default
-                            ? boundaryMod.default
-                            : null;
-                    if (boundaryMod &&
-                        boundaryMod.config &&
-                        typeof boundaryMod.config === 'object') {
-                        boundaryConfig = boundaryMod.config;
-                    }
-                    else if (boundaryDefault &&
-                        typeof boundaryDefault === 'function' &&
-                        boundaryDefault.prototype &&
-                        boundaryDefault.prototype[BOUNDARY_CONFIG]) {
-                        // Class-based boundary with @Boundary
-                        boundaryConfig = boundaryDefault.prototype[BOUNDARY_CONFIG];
-                    }
-                    else if (boundaryDefault && typeof boundaryDefault === 'object') {
-                        boundaryConfig = boundaryDefault;
-                    }
-                    else if (boundaryMod && typeof boundaryMod === 'object') {
-                        boundaryConfig = boundaryMod;
-                    }
-                    const isExcluded = (reqPath, reqMethod) => {
-                        if (!boundaryConfig || !boundaryConfig.exclude)
-                            return false;
-                        for (const rule of boundaryConfig.exclude) {
-                            if (typeof rule === 'string') {
-                                if (rule.endsWith('/*')) {
-                                    if (reqPath.startsWith(rule.slice(0, -2)))
-                                        return true;
-                                }
-                                else if (reqPath === rule)
-                                    return true;
-                            }
-                            else {
-                                const pathMatch = rule.path.endsWith('/*')
-                                    ? reqPath.startsWith(rule.path.slice(0, -2))
-                                    : reqPath === rule.path;
-                                if (pathMatch) {
-                                    const methods = rule.methods || (rule.method ? [rule.method] : undefined);
-                                    if (!methods || methods.includes(reqMethod))
-                                        return true;
-                                }
-                            }
-                        }
-                        return false;
-                    };
-                    // 1. Auto-detect named middleware functions: (req, res, next)
-                    if (boundaryMod && typeof boundaryMod === 'object') {
-                        for (const [exportKey, exportVal] of Object.entries(boundaryMod)) {
-                            if (exportKey !== 'default' &&
-                                exportKey !== 'config' &&
-                                exportKey !== 'beforeHandle' &&
-                                exportKey !== 'afterHandle' &&
-                                typeof exportVal === 'function' &&
-                                exportVal.length >= 3 // (req, res, next)
-                            ) {
-                                const namedMiddleware = (req, res, next) => isExcluded(req.path, req.method)
-                                    ? next()
-                                    : exportVal(req, res, next);
-                                allMiddlewares.push(namedMiddleware);
-                            }
-                        }
-                        if (typeof boundaryMod.beforeHandle === 'function' &&
-                            !boundaryConfig?.beforeHandle) {
-                            if (!boundaryConfig)
-                                boundaryConfig = {};
-                            boundaryConfig.beforeHandle = boundaryMod.beforeHandle;
-                        }
-                        if (typeof boundaryMod.afterHandle === 'function' &&
-                            !boundaryConfig?.afterHandle) {
-                            if (!boundaryConfig)
-                                boundaryConfig = {};
-                            boundaryConfig.afterHandle = boundaryMod.afterHandle;
-                        }
-                    }
-                    // 2. Auto-detect pipeline wrapper function: export default async function(ctx, next)
-                    // or class method named `handle(ctx, next)`
-                    let wrapperFn = null;
-                    if (boundaryDefault &&
-                        typeof boundaryDefault === 'function' &&
-                        boundaryDefault.length === 2 &&
-                        !boundaryDefault.prototype?.[BOUNDARY_CONFIG]) {
-                        wrapperFn = boundaryDefault;
-                    }
-                    else if (boundaryDefault &&
-                        typeof boundaryDefault === 'function' &&
-                        boundaryDefault.prototype &&
-                        boundaryDefault.prototype[BOUNDARY_CONFIG]) {
-                        const proto = boundaryDefault.prototype;
-                        if (typeof proto.handle === 'function') {
-                            const boundaryInstance = new boundaryDefault();
-                            wrapperFn = proto.handle.bind(boundaryInstance);
-                        }
-                        // Also inspect method middlewares on class boundary
-                        for (const prop of Object.getOwnPropertyNames(proto)) {
-                            if (prop !== 'constructor' &&
-                                prop !== 'handle' &&
-                                prop !== 'beforeHandle' &&
-                                prop !== 'afterHandle') {
-                                const methodVal = proto[prop];
-                                if (typeof methodVal === 'function' && methodVal.length >= 3) {
-                                    const boundaryInstance = new boundaryDefault();
-                                    const namedMiddleware = (req, res, next) => isExcluded(req.path, req.method)
-                                        ? next()
-                                        : methodVal.call(boundaryInstance, req, res, next);
-                                    allMiddlewares.push(namedMiddleware);
-                                }
-                            }
-                        }
-                        if (typeof proto.beforeHandle === 'function' &&
-                            !boundaryConfig?.beforeHandle) {
-                            const boundaryInstance = new boundaryDefault();
-                            if (!boundaryConfig)
-                                boundaryConfig = {};
-                            boundaryConfig.beforeHandle =
-                                proto.beforeHandle.bind(boundaryInstance);
-                        }
-                        if (typeof proto.afterHandle === 'function' &&
-                            !boundaryConfig?.afterHandle) {
-                            const boundaryInstance = new boundaryDefault();
-                            if (!boundaryConfig)
-                                boundaryConfig = {};
-                            boundaryConfig.afterHandle =
-                                proto.afterHandle.bind(boundaryInstance);
-                        }
-                    }
-                    if (wrapperFn) {
-                        const capturedWrapper = wrapperFn;
-                        const wrapperMiddleware = (req, res, next) => {
-                            if (isExcluded(req.path, req.method))
-                                return next();
-                            let nextCalled = false;
-                            let nextResolve;
-                            let _nextReject;
-                            const nextPromise = new Promise((resolve, reject) => {
-                                nextResolve = resolve;
-                                _nextReject = reject;
-                            });
-                            // Intercept response methods to catch handler return values
-                            const originalJson = res.json.bind(res);
-                            const originalSend = res.send.bind(res);
-                            let handledByRoute = false;
-                            res.json = function (body) {
-                                if (!handledByRoute) {
-                                    handledByRoute = true;
-                                    nextResolve(body);
-                                }
-                                else {
-                                    return originalJson(body);
-                                }
-                                return this;
-                            };
-                            res.send = function (body) {
-                                if (!handledByRoute) {
-                                    handledByRoute = true;
-                                    nextResolve(body);
-                                }
-                                else {
-                                    return originalSend(body);
-                                }
-                                return this;
-                            };
-                            const ctx = {
-                                req,
-                                res,
-                                app: this.app,
-                                resolve: (token) => this.app.resolve(token, req._diCache),
-                            };
-                            capturedWrapper(ctx, async () => {
-                                if (!nextCalled) {
-                                    nextCalled = true;
-                                    next();
-                                }
-                                return nextPromise;
-                            })
-                                .then((wrapperResult) => {
-                                if (wrapperResult !== undefined && !res.headersSent) {
-                                    if (typeof wrapperResult === 'object' &&
-                                        wrapperResult !== null) {
-                                        originalJson(wrapperResult);
-                                    }
-                                    else {
-                                        originalSend(String(wrapperResult));
-                                    }
-                                }
-                            })
-                                .catch((wrapperErr) => {
-                                next(wrapperErr);
-                            });
-                        };
-                        allMiddlewares.push(wrapperMiddleware);
-                    }
-                    if (boundaryConfig) {
-                        const bMiddleware = boundaryConfig.middleware || boundaryConfig.middlewares;
-                        if (bMiddleware) {
-                            const mList = Array.isArray(bMiddleware)
-                                ? bMiddleware
-                                : [bMiddleware];
-                            const wrapped = mList.map((m) => (req, res, next) => isExcluded(req.path, req.method) ? next() : m(req, res, next));
-                            allMiddlewares.push(...wrapped);
-                        }
-                        if (boundaryConfig.filters) {
-                            const wrapped = boundaryConfig.filters.map((f) => (err, req, res, next) => isExcluded(req.path, req.method)
-                                ? next(err)
-                                : f.prototype && f.prototype.catch
-                                    ? new f().catch(err, req, res, next)
-                                    : f(err, req, res, next));
-                            allFilters.push(...wrapped);
-                        }
-                        if (boundaryConfig.guards) {
-                            const wrapped = boundaryConfig.guards.map((g) => {
-                                return async (req) => {
-                                    if (isExcluded(req.path, req.method))
-                                        return true;
-                                    return typeof g === 'function'
-                                        ? g.prototype?.canActivate
-                                            ? new g().canActivate(req)
-                                            : g(req)
-                                        : g.canActivate(req);
-                                };
-                            });
-                            allGuards.push(...wrapped);
-                        }
-                        if (boundaryConfig.interceptors) {
-                            const wrapped = boundaryConfig.interceptors.map((i) => {
-                                return async (req, res) => {
-                                    if (isExcluded(req.path, req.method))
-                                        return;
-                                    return typeof i === 'function'
-                                        ? i.prototype?.intercept
-                                            ? new i().intercept(req, res)
-                                            : i(req, res)
-                                        : i.intercept(req, res);
-                                };
-                            });
-                            allInterceptors.push(...wrapped);
-                        }
-                        if (boundaryConfig.beforeHandle || boundaryConfig.afterHandle) {
-                            const beforeHooks = (Array.isArray(boundaryConfig.beforeHandle)
-                                ? boundaryConfig.beforeHandle
-                                : boundaryConfig.beforeHandle
-                                    ? [boundaryConfig.beforeHandle]
-                                    : []);
-                            const afterHooks = (Array.isArray(boundaryConfig.afterHandle)
-                                ? boundaryConfig.afterHandle
-                                : boundaryConfig.afterHandle
-                                    ? [boundaryConfig.afterHandle]
-                                    : []);
-                            const hookMiddleware = async (req, res, next) => {
-                                if (isExcluded(req.path, req.method))
-                                    return next();
-                                for (const hook of beforeHooks) {
-                                    try {
-                                        const result = await hook(req, res);
-                                        if (result === false) {
-                                            if (!res.headersSent) {
-                                                res.status(403).json({
-                                                    success: false,
-                                                    error: {
-                                                        code: 'FORBIDDEN',
-                                                        message: 'Forbidden by boundary guard',
-                                                    },
-                                                });
-                                            }
-                                            return;
-                                        }
-                                        if (res.headersSent)
-                                            return;
-                                    }
-                                    catch (err) {
-                                        return next(err);
-                                    }
-                                }
-                                if (afterHooks.length === 0) {
-                                    return next();
-                                }
-                                const originalJson = res.json.bind(res);
-                                const originalSend = res.send.bind(res);
-                                let handled = false;
-                                res.json = function (body) {
-                                    if (handled)
-                                        return originalJson(body);
-                                    handled = true;
-                                    const runAfterHooks = async () => {
-                                        let currentData = body;
-                                        for (const afterHook of afterHooks) {
-                                            const transformed = await afterHook(req, res, currentData);
-                                            if (transformed !== undefined) {
-                                                currentData = transformed;
-                                            }
-                                            if (res.headersSent)
-                                                return;
-                                        }
-                                        originalJson(currentData);
-                                    };
-                                    runAfterHooks().catch((err) => {
-                                        next(err);
-                                    });
-                                    return this;
-                                };
-                                res.send = function (body) {
-                                    if (handled)
-                                        return originalSend(body);
-                                    handled = true;
-                                    const runAfterHooks = async () => {
-                                        let currentData = body;
-                                        for (const afterHook of afterHooks) {
-                                            const transformed = await afterHook(req, res, currentData);
-                                            if (transformed !== undefined) {
-                                                currentData = transformed;
-                                            }
-                                            if (res.headersSent)
-                                                return;
-                                        }
-                                        originalSend(currentData);
-                                    };
-                                    runAfterHooks().catch((err) => {
-                                        next(err);
-                                    });
-                                    return this;
-                                };
-                                next();
-                            };
-                            allMiddlewares.push(hookMiddleware);
-                        }
-                        if (boundaryConfig.timeout !== undefined) {
-                            const baseTimeout = boundaryConfig.timeout;
-                            const timeoutMiddleware = (req, res, next) => {
-                                if (isExcluded(req.path, req.method))
-                                    return next();
-                                const ms = typeof baseTimeout === 'function'
-                                    ? baseTimeout(req)
-                                    : baseTimeout;
-                                if (ms) {
-                                    req.timeoutTimer = setTimeout(() => {
-                                        if (!res.headersSent) {
-                                            res.status(408).json({
-                                                success: false,
-                                                error: {
-                                                    code: 'REQUEST_TIMEOUT',
-                                                    message: 'Request Timeout',
-                                                },
-                                            });
-                                        }
-                                    }, ms);
-                                    res.raw.on('finish', () => clearTimeout(req.timeoutTimer));
-                                }
-                                next();
-                            };
-                            allMiddlewares.push(timeoutMiddleware);
-                        }
-                        if (boundaryConfig.metadata) {
-                            allMetadata = { ...allMetadata, ...boundaryConfig.metadata };
-                        }
-                        if (boundaryConfig.cors !== undefined)
-                            allCors = boundaryConfig.cors;
-                        if (boundaryConfig.headers)
-                            allHeaders = { ...allHeaders, ...boundaryConfig.headers };
-                        if (boundaryConfig.plugins) {
-                            for (const plugin of boundaryConfig.plugins) {
-                                await this.app.pluginManager.register(plugin);
-                            }
-                        }
-                        if (boundaryConfig.imports) {
-                            for (const mod of boundaryConfig.imports) {
-                                const name = 'plugin' in mod ? mod.plugin.name : mod.name;
-                                if (!this.app.pluginManager.hasPlugin(name)) {
-                                    await this.app.pluginManager.register(mod);
-                                }
-                            }
-                        }
-                        if (boundaryConfig.providers) {
-                            for (const [token, providerConfig] of boundaryConfig.providers) {
-                                this.app.container.provide(token, providerConfig);
-                            }
-                        }
-                    }
-                }
-            }
-            catch {
-                /* ignore */
-            }
+        const { activeBoundaries, boundaryMiddlewares, boundaryFilters, boundaryGuards, boundaryInterceptors, boundaryMetadata, boundaryCors, boundaryHeaders, hasBoundaries, } = await (0, scanner_1.loadActiveBoundaries)(filePath, this.apiDir || path.dirname(filePath), this.app);
+        if (hasBoundaries) {
+            this.hasBoundaries = true;
         }
+        const allMiddlewares = [...boundaryMiddlewares];
+        let allCors = boundaryCors;
+        let allHeaders = { ...boundaryHeaders };
         const currentMod = mod && mod.default && mod.default.default
             ? mod.default.default
             : mod && mod.default
@@ -784,10 +356,12 @@ class RouteScanner {
         else if (allCors === undefined && this.app.options.cors !== undefined)
             allCors = this.app.options.cors;
         const rMiddleware = routeConfig.middleware || routeConfig.middlewares;
-        if (rMiddleware)
+        if (rMiddleware) {
             allMiddlewares.push(...(Array.isArray(rMiddleware) ? rMiddleware : [rMiddleware]));
-        if (routeConfig.headers)
+        }
+        if (routeConfig.headers) {
             allHeaders = { ...allHeaders, ...routeConfig.headers };
+        }
         if (routeConfig.plugins) {
             for (const plugin of routeConfig.plugins) {
                 await this.app.pluginManager.register(plugin);
@@ -795,7 +369,7 @@ class RouteScanner {
         }
         // Pass boundary features to controllers via metadata if necessary
         const combinedFilters = [
-            ...allFilters,
+            ...boundaryFilters,
             ...(routeConfig.filters
                 ? Array.isArray(routeConfig.filters)
                     ? routeConfig.filters
@@ -803,7 +377,7 @@ class RouteScanner {
                 : []),
         ];
         const combinedGuards = [
-            ...allGuards,
+            ...boundaryGuards,
             ...(routeConfig.guards
                 ? Array.isArray(routeConfig.guards)
                     ? routeConfig.guards
@@ -811,7 +385,7 @@ class RouteScanner {
                 : []),
         ];
         const combinedInterceptors = [
-            ...allInterceptors,
+            ...boundaryInterceptors,
             ...(routeConfig.interceptors
                 ? Array.isArray(routeConfig.interceptors)
                     ? routeConfig.interceptors
@@ -833,7 +407,7 @@ class RouteScanner {
                 if (!mod.default.metadata)
                     mod.default.metadata = {};
                 Object.assign(mod.default.metadata, {
-                    ...allMetadata,
+                    ...boundaryMetadata,
                     ...(routeConfig.metadata || {}),
                 });
             }
@@ -843,13 +417,10 @@ class RouteScanner {
         }
         const prefixMiddlewares = [];
         if (this.app.options.debugRouting) {
-            const pathLib = await Promise.resolve().then(() => __importStar(require('node:path')));
-            const relFile = pathLib
-                .relative(process.cwd(), filePath)
-                .replace(/\\/g, '/');
+            const relFile = path.relative(process.cwd(), filePath).replace(/\\/g, '/');
             const boundaryStr = activeBoundaries.length > 0
                 ? activeBoundaries
-                    .map((g) => pathLib.relative(process.cwd(), g).replace(/\\/g, '/'))
+                    .map((g) => path.relative(process.cwd(), g).replace(/\\/g, '/'))
                     .join(' -> ') + ' -> '
                 : '';
             prefixMiddlewares.push((req, res, next) => {
@@ -912,224 +483,7 @@ class RouteScanner {
         }
     }
     compileFunctionalController(config) {
-        const router = new router_1.Router();
-        const fileMiddleware = [];
-        if (config.cors) {
-            fileMiddleware.push(config.cors === true ? (0, middleware_1.cors)({}) : (0, middleware_1.cors)(config.cors));
-        }
-        const fileMiddlewareConfig = config.middleware || config.middlewares;
-        if (fileMiddlewareConfig) {
-            fileMiddleware.push(...(Array.isArray(fileMiddlewareConfig)
-                ? fileMiddlewareConfig
-                : [fileMiddlewareConfig]));
-        }
-        const { onError, onResponse } = config;
-        for (const [key, routeConfig] of Object.entries(config)) {
-            if ([
-                'cors',
-                'middleware',
-                'middlewares',
-                'onError',
-                'onResponse',
-                '__isController',
-            ].includes(key))
-                continue;
-            const rc = routeConfig;
-            if (!rc || !rc.method || !rc.path || !rc.handle)
-                continue;
-            const routeMiddlewares = [...fileMiddleware];
-            if (rc.cors) {
-                routeMiddlewares.push(rc.cors === true ? (0, middleware_1.cors)({}) : (0, middleware_1.cors)(rc.cors));
-            }
-            const rcMiddleware = rc.middleware || rc.middlewares;
-            if (rcMiddleware) {
-                routeMiddlewares.push(...(Array.isArray(rcMiddleware) ? rcMiddleware : [rcMiddleware]));
-            }
-            // ─── SUPER HANDLER WRAPPER ───
-            const superHandler = async (req, res, next) => {
-                if (onResponse) {
-                    res.raw.on('finish', () => onResponse(req, res));
-                }
-                try {
-                    // Dynamic Route Timeout Override
-                    const routeTimeoutVal = rc.timeoutMs !== undefined ? rc.timeoutMs : rc.timeout;
-                    if (routeTimeoutVal !== undefined &&
-                        typeof req.setTimeout === 'function') {
-                        const ms = typeof routeTimeoutVal === 'number'
-                            ? routeTimeoutVal
-                            : routeTimeoutVal?.ms;
-                        if (typeof ms === 'number') {
-                            if (ms <= 0)
-                                req.clearTimeout?.();
-                            else
-                                req.setTimeout(ms);
-                        }
-                    }
-                    // 0. Enforce Route Permissions (Role Authorization)
-                    if (rc.permissions && rc.permissions.length > 0) {
-                        if (!req.user) {
-                            res.status(401).json({
-                                success: false,
-                                error: {
-                                    code: 'UNAUTHORIZED',
-                                    message: 'Unauthorized: User not found on request',
-                                },
-                            });
-                            return;
-                        }
-                        const userPerms = req.user.permissions || req.user.roles || req.user.role || [];
-                        const permsArray = Array.isArray(userPerms)
-                            ? userPerms
-                            : [userPerms];
-                        const hasPerm = rc.permissions.every((p) => permsArray.includes(p));
-                        if (!hasPerm) {
-                            res.status(403).json({
-                                success: false,
-                                error: {
-                                    code: 'FORBIDDEN',
-                                    message: 'Forbidden: Insufficient permissions',
-                                },
-                            });
-                            return;
-                        }
-                    }
-                    // 1. Run Guards
-                    const routeGuards = [...(config.guards || []), ...(rc.guards || [])];
-                    for (const guard of routeGuards) {
-                        const allowed = await (typeof guard === 'function'
-                            ? guard.prototype?.canActivate
-                                ? new guard().canActivate(req)
-                                : guard(req)
-                            : guard.canActivate(req));
-                        if (!allowed) {
-                            if (res && !res.headersSent) {
-                                res.status(403).json({
-                                    success: false,
-                                    error: { code: 'FORBIDDEN', message: 'Forbidden by Guard' },
-                                });
-                            }
-                            return;
-                        }
-                    }
-                    // Build Context
-                    const ctx = {
-                        body: req.body,
-                        query: req.query,
-                        params: req.params,
-                        headers: req.headers,
-                        file: req.file,
-                        files: req.files,
-                        fields: req.body,
-                        req,
-                        res,
-                        app: this.app,
-                        resolve: (token) => this.app.resolve(token, req._diCache),
-                        socket: req.ws,
-                        state: context_1.executionContext.getStore()?.state || {},
-                    };
-                    if (req.user !== undefined)
-                        ctx.user = req.user;
-                    if (req.session !== undefined)
-                        ctx.session = req.session;
-                    const result = await rc.handle(ctx);
-                    // 2. Run Interceptors
-                    const routeInterceptors = [
-                        ...(config.interceptors || []),
-                        ...(rc.interceptors || []),
-                    ];
-                    for (const interceptor of routeInterceptors) {
-                        await (typeof interceptor === 'function'
-                            ? interceptor.prototype?.intercept
-                                ? new interceptor().intercept(req, res)
-                                : interceptor(req, res)
-                            : interceptor.intercept(req, res));
-                    }
-                    if (result !== undefined && !res.headersSent) {
-                        if (typeof result === 'object' && result !== null) {
-                            res.json(result);
-                        }
-                        else {
-                            res.send(String(result));
-                        }
-                    }
-                }
-                catch (err) {
-                    if (onError) {
-                        try {
-                            await onError(err, req, res);
-                        }
-                        catch (hookErr) {
-                            next(hookErr);
-                        }
-                    }
-                    else {
-                        next(err); // Hands off to ExisJS global error handler (which handles HttpErrors automatically!)
-                    }
-                }
-            };
-            // Mount to router
-            const method = rc.method.toLowerCase();
-            const schema = {};
-            const isValidatorOrPipe = (v) => v.parse ||
-                v.transform ||
-                (typeof v === 'function' && v.prototype?.transform);
-            if (rc.body) {
-                schema.body = isValidatorOrPipe(rc.body) ? rc.body : index_1.tex.object(rc.body);
-            }
-            if (rc.query) {
-                schema.query = isValidatorOrPipe(rc.query)
-                    ? rc.query
-                    : index_1.tex.object(rc.query);
-            }
-            if (rc.params) {
-                schema.params = isValidatorOrPipe(rc.params)
-                    ? rc.params
-                    : index_1.tex.object(rc.params);
-            }
-            if (rc.host) {
-                schema.host = rc.host;
-            }
-            if (rc.timeoutMs !== undefined) {
-                schema.timeoutMs = rc.timeoutMs;
-            }
-            if (rc.timeout !== undefined) {
-                schema.timeout = rc.timeout;
-            }
-            if (rc.upload !== undefined) {
-                schema.upload = rc.upload;
-            }
-            const combinedFilters = [
-                ...(config.filters
-                    ? Array.isArray(config.filters)
-                        ? config.filters
-                        : [config.filters]
-                    : []),
-                ...(rc.filters
-                    ? Array.isArray(rc.filters)
-                        ? rc.filters
-                        : [rc.filters]
-                    : []),
-            ];
-            if (combinedFilters.length > 0) {
-                schema.filters = combinedFilters;
-            }
-            const combinedMetadata = {
-                ...(config.metadata || {}),
-                ...(rc.metadata || {}),
-            };
-            if (Object.keys(combinedMetadata).length > 0) {
-                schema.metadata = combinedMetadata;
-            }
-            if (Object.keys(schema).length > 0) {
-                ;
-                router[method](rc.path, ...routeMiddlewares, schema, superHandler);
-            }
-            else {
-                ;
-                router[method](rc.path, ...routeMiddlewares, superHandler);
-            }
-        }
-        return router;
+        return (0, scanner_1.compileFunctionalController)(config, this.app);
     }
     mountRouteWithSource(prefix, subRouter, sourceFile, prefixMiddlewares = []) {
         for (const route of subRouter.getRoutes()) {
@@ -1151,95 +505,20 @@ class RouteScanner {
         }
         return this;
     }
+    mountErrorHandlerFromModule(mod, errorFile = 'error.ts') {
+        (0, scanner_1.mountErrorHandlerFromModule)(mod, this.app, errorFile);
+    }
     async mountErrorHandler(dir) {
-        const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
-        const path = await Promise.resolve().then(() => __importStar(require('node:path')));
-        const candidateFiles = [
-            path.join(dir, 'error.ts'),
-            path.join(dir, 'error.js'),
-            path.join(dir, 'error.mjs'),
-            path.join(dir, 'error.cjs'),
-        ];
-        let errorFile = null;
-        for (const file of candidateFiles) {
-            try {
-                const stat = await fs.stat(file);
-                if (stat.isFile()) {
-                    errorFile = file;
-                    break;
-                }
-            }
-            catch {
-                // ignore
-            }
-        }
-        if (!errorFile)
-            return;
-        try {
-            const url = process.env.VITEST || process.env.NODE_ENV === 'test'
-                ? (0, node_url_1.pathToFileURL)(errorFile).href
-                : (0, node_url_1.pathToFileURL)(errorFile).href + '?t=' + Date.now();
-            let mod;
-            if (process.env.VITEST || process.env.NODE_ENV === 'test') {
-                mod = await Promise.resolve(`${url}`).then(s => __importStar(require(s)));
-            }
-            else {
-                const dynamicImport = new Function('specifier', 'return import(specifier)');
-                mod = await dynamicImport(url);
-            }
-            const unwrapped = mod && mod.default && mod.default.default
-                ? mod.default.default
-                : mod && mod.default
-                    ? mod.default
-                    : mod;
-            const handler = mod.onError ||
-                (unwrapped && unwrapped.onError) ||
-                (typeof unwrapped === 'function' ? unwrapped : null) ||
-                mod.errorHandler ||
-                mod.handleError;
-            if (typeof handler === 'function') {
-                if (handler.length === 4) {
-                    this.app.use(handler);
-                }
-                else {
-                    this.app.onError(handler);
-                }
-                this.app.log.info({ file: errorFile }, 'Mounted global error handler from error.ts');
-            }
-        }
-        catch (err) {
-            this.app.log.error({ err, file: errorFile }, `Failed to load error handler file: ${errorFile}`);
-        }
+        await (0, scanner_1.mountErrorHandler)(dir, this.app);
     }
     async scanDirectory(dir, baseRoute = '/') {
-        const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
-        const path = await Promise.resolve().then(() => __importStar(require('node:path')));
-        const entries = await fs.readdir(dir, { withFileTypes: true });
-        const results = [];
-        for (const entry of entries) {
-            const fullPath = path.join(dir, entry.name);
-            if (entry.isDirectory()) {
-                let segment = entry.name;
-                if (segment.startsWith('(') && segment.endsWith(')')) {
-                    const subResults = await this.scanDirectory(fullPath, baseRoute);
-                    results.push(...subResults);
-                    continue;
-                }
-                if (segment.startsWith('[...') && segment.endsWith(']')) {
-                    segment = '*' + segment.slice(4, -1);
-                }
-                else {
-                    segment = segment.replace(/\[(.*?)\]/g, ':$1');
-                }
-                const nextBase = baseRoute === '/' ? `/${segment}` : `${baseRoute}/${segment}`;
-                const subResults = await this.scanDirectory(fullPath, nextBase);
-                results.push(...subResults);
-            }
-            else {
-                results.push({ filePath: fullPath, routePath: baseRoute });
-            }
-        }
-        return results;
+        return (0, scanner_1.scanDirectory)(dir, baseRoute);
+    }
+    async mountCronJobs(root) {
+        await (0, scanner_1.mountCronJobs)(root, this.app, this._allApiDirs);
+    }
+    mountCronJobsFromEntries(entries) {
+        (0, scanner_1.mountCronJobsFromEntries)(entries, this.app);
     }
 }
 exports.RouteScanner = RouteScanner;