exisjs 0.6.0 → 0.7.0

package/dist/router/route-scanner.js

@@ -46,7 +46,7 @@ class RouteScanner {
         this.lazyRoutes = new Map();
         this.routeMap = new Map();
         this.apiDir = null;
-        this.hasGateways = false;
+        this.hasBoundaries = false;
         this.globalParadigm = null;
     }
     async loadAllRoutes() {
@@ -173,18 +173,12 @@ class RouteScanner {
         this.apiDir = appDirs[0] // keep property name for backwards compatibility
         ;
         this._allApiDirs = appDirs;
-        const cc = {
-            green: '\x1b[32m',
-            cyan: '\x1b[36m',
-            gray: '\x1b[90m',
-            reset: '\x1b[0m',
-        };
         for (const appDir of appDirs) {
             const routes = await this.scanDirectory(appDir);
             for (const { filePath, routePath } of routes) {
-                if (filePath.endsWith('gateway.ts') ||
-                    filePath.endsWith('gateway.js')) {
-                    this.hasGateways = true;
+                if (filePath.endsWith('boundary.ts') ||
+                    filePath.endsWith('boundary.js')) {
+                    this.hasBoundaries = true;
                 }
                 if (filePath.endsWith('route.ts') || filePath.endsWith('route.js')) {
                     const normalized = path.resolve(filePath);
@@ -202,14 +196,6 @@ class RouteScanner {
                                 this.app.getRouter().removeRoutesBySource('lazy:' + lazyKey);
                                 try {
                                     await this.mountRouteFile(normalized, routePath);
-                                    const relative = path
-                                        .relative(process.cwd(), normalized)
-                                        .replace(/\\/g, '/');
-                                    const now = new Date();
-                                    const h = String(now.getHours()).padStart(2, '0');
-                                    const m = String(now.getMinutes()).padStart(2, '0');
-                                    const s = String(now.getSeconds()).padStart(2, '0');
-                                    console.log(`${cc.gray}[${h}:${m}:${s}]${cc.reset} ${cc.green}HMR:${cc.reset} Lazy loaded ${cc.cyan}${relative}${cc.reset}`);
                                 }
                                 catch (err) {
                                     (0, error_overlay_1.formatDevError)(err, normalized);
@@ -289,78 +275,11 @@ class RouteScanner {
             else if (functionalFiles.length > 0)
                 this.globalParadigm = 'functional';
         }
-        if (!this.hasGateways && !isProd) {
-            console.warn('\x1b[33m[ExisJS] Warning: No gateway.ts found — applying default security headers.\x1b[0m');
+        if (!this.hasBoundaries && !isProd) {
+            console.warn('\x1b[33m[ExisJS] Warning: No boundary.ts found — applying default security headers.\x1b[0m');
         }
     }
     // ─── Route File Mounting (shared by autoMount and HotReloader) ──────────────
-    // ─── Auto-Mount File-Based Jobs ──────────────────────────────────────────────
-    async autoMountJobs(root) {
-        if (!this.app._queueWorker)
-            return;
-        const fs = await Promise.resolve().then(() => __importStar(require('node:fs/promises')));
-        const path = await Promise.resolve().then(() => __importStar(require('node:path')));
-        const isProd = process.env.NODE_ENV === 'production';
-        const searchDirs = isProd
-            ? [
-                path.join(root, '.exis', 'server', 'src', 'jobs'),
-                path.join(root, 'dist', 'src', 'jobs'),
-                path.join(root, 'src', 'jobs'),
-            ]
-            : [path.join(root, 'src', 'jobs')];
-        let jobsDir = '';
-        for (const dir of searchDirs) {
-            try {
-                const stat = await fs.stat(dir);
-                if (stat.isDirectory()) {
-                    jobsDir = dir;
-                    break;
-                }
-            }
-            catch {
-                /* ignore */
-            }
-        }
-        if (!jobsDir)
-            return;
-        try {
-            const entries = await fs.readdir(jobsDir, { withFileTypes: true });
-            for (const entry of entries) {
-                if (entry.isFile() &&
-                    (entry.name.endsWith('.ts') || entry.name.endsWith('.js'))) {
-                    const filePath = path.join(jobsDir, entry.name);
-                    const name = entry.name.replace(/\.(ts|js)$/, '');
-                    try {
-                        // Load the definition directly (no compilation needed here just to get the schema)
-                        const mod = await Promise.resolve(`${filePath}`).then(s => __importStar(require(s)));
-                        const jobDef = mod.default || mod;
-                        if (jobDef) {
-                            const def = {
-                                name: jobDef.name || name,
-                                filePath, // Attach filePath for Thread Pool execution
-                                cron: jobDef.cron,
-                                schema: jobDef.schema,
-                                defaultOptions: jobDef.defaultOptions,
-                            };
-                            this.app._queueWorker.registerJob(def);
-                            if (this.app._cronScheduler && jobDef.cron) {
-                                this.app._cronScheduler.registerJob(def);
-                            }
-                            if (!process.env.__EXIS_IS_RESTART) {
-                                this.app.log.info(`Registered background job: ${name}`);
-                            }
-                        }
-                    }
-                    catch (err) {
-                        this.app.log.error(`Failed to load job file ${filePath}: ${err}`);
-                    }
-                }
-            }
-        }
-        catch {
-            // Ignore if jobs directory does not exist
-        }
-    }
     async mountRouteFile(filePath, routePath) {
         let mod;
         try {
@@ -395,7 +314,7 @@ class RouteScanner {
         let allMetadata = {};
         let allCors = undefined;
         let allHeaders = {};
-        const activeGateways = [];
+        const activeBoundaries = [];
         const dirsToCheck = [apiDir];
         let tempDir = apiDir;
         for (const segment of segments) {
@@ -404,78 +323,212 @@ class RouteScanner {
         }
         for (const dir of dirsToCheck) {
             try {
-                const gwPathJs = path.join(dir, 'gateway.js');
-                const gwPathTs = path.join(dir, 'gateway.ts');
-                let targetGw = '';
-                if (await fs.stat(gwPathTs).catch(() => null))
-                    targetGw = gwPathTs;
-                else if (await fs.stat(gwPathJs).catch(() => null))
-                    targetGw = gwPathJs;
-                if (targetGw) {
-                    activeGateways.push(targetGw);
-                    this.hasGateways = true;
-                    const gwUrl = process.env.VITEST || process.env.NODE_ENV === 'test'
-                        ? (0, node_url_1.pathToFileURL)(targetGw).href
-                        : (0, node_url_1.pathToFileURL)(targetGw).href + '?t=' + Date.now();
-                    let gwMod;
+                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;
+                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') {
-                            gwMod = await Promise.resolve(`${gwUrl}`).then(s => __importStar(require(s)));
+                            boundaryMod = await Promise.resolve(`${boundaryUrl}`).then(s => __importStar(require(s)));
                         }
                         else {
-                            const dynamicImportGw = new Function('specifier', 'return import(specifier)');
-                            gwMod = await dynamicImportGw(gwUrl);
+                            const dynamicImportBoundary = new Function('specifier', 'return import(specifier)');
+                            boundaryMod = await dynamicImportBoundary(boundaryUrl);
                         }
                     }
                     catch {
                         // eslint-disable-next-line @typescript-eslint/no-require-imports
-                        gwMod = require(targetGw);
+                        boundaryMod = require(targetBoundary);
                     }
-                    const gwConfig = gwMod && gwMod.default && gwMod.default.default
-                        ? gwMod.default.default
-                        : gwMod && gwMod.default
-                            ? gwMod.default
-                            : gwMod;
-                    if (gwConfig) {
-                        const isExcluded = (reqPath, reqMethod) => {
-                            if (!gwConfig.exclude)
-                                return false;
-                            for (const rule of gwConfig.exclude) {
-                                if (typeof rule === 'string') {
-                                    if (rule.endsWith('/*')) {
-                                        if (reqPath.startsWith(rule.slice(0, -2)))
-                                            return true;
-                                    }
-                                    else if (reqPath === rule)
+                    // 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' &&
+                                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);
+                            }
+                        }
+                    }
+                    // 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') {
+                                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 (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 {
-                                    const pathMatch = rule.path.endsWith('/*')
-                                        ? reqPath.startsWith(rule.path.slice(0, -2))
-                                        : reqPath === rule.path;
-                                    if (pathMatch) {
-                                        if (!rule.methods ||
-                                            rule.methods.includes(reqMethod))
-                                            return true;
+                                    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));
                                     }
                                 }
-                            }
-                            return false;
+                            })
+                                .catch((wrapperErr) => {
+                                next(wrapperErr);
+                            });
                         };
-                        if (gwConfig.middleware) {
-                            const wrapped = gwConfig.middleware.map((m) => (req, res, next) => isExcluded(req.path, req.method) ? next() : m(req, res, next));
+                        allMiddlewares.push(wrapperMiddleware);
+                    }
+                    if (boundaryConfig) {
+                        if (boundaryConfig.middleware) {
+                            const wrapped = boundaryConfig.middleware.map((m) => (req, res, next) => isExcluded(req.path, req.method) ? next() : m(req, res, next));
                             allMiddlewares.push(...wrapped);
                         }
-                        if (gwConfig.filters) {
-                            const wrapped = gwConfig.filters.map((f) => (err, req, res, next) => isExcluded(req.path, req.method)
+                        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 (gwConfig.guards) {
-                            const wrapped = gwConfig.guards.map((g) => {
+                        if (boundaryConfig.guards) {
+                            const wrapped = boundaryConfig.guards.map((g) => {
                                 return async (req) => {
                                     if (isExcluded(req.path, req.method))
                                         return true;
@@ -488,8 +541,8 @@ class RouteScanner {
                             });
                             allGuards.push(...wrapped);
                         }
-                        if (gwConfig.interceptors) {
-                            const wrapped = gwConfig.interceptors.map((i) => {
+                        if (boundaryConfig.interceptors) {
+                            const wrapped = boundaryConfig.interceptors.map((i) => {
                                 return async (req, res) => {
                                     if (isExcluded(req.path, req.method))
                                         return;
@@ -502,8 +555,8 @@ class RouteScanner {
                             });
                             allInterceptors.push(...wrapped);
                         }
-                        if (gwConfig.timeout !== undefined) {
-                            const baseTimeout = gwConfig.timeout;
+                        if (boundaryConfig.timeout !== undefined) {
+                            const baseTimeout = boundaryConfig.timeout;
                             const timeoutMiddleware = (req, res, next) => {
                                 if (isExcluded(req.path, req.method))
                                     return next();
@@ -528,28 +581,28 @@ class RouteScanner {
                             };
                             allMiddlewares.push(timeoutMiddleware);
                         }
-                        if (gwConfig.metadata) {
-                            allMetadata = { ...allMetadata, ...gwConfig.metadata };
+                        if (boundaryConfig.metadata) {
+                            allMetadata = { ...allMetadata, ...boundaryConfig.metadata };
                         }
-                        if (gwConfig.cors !== undefined)
-                            allCors = gwConfig.cors;
-                        if (gwConfig.headers)
-                            allHeaders = { ...allHeaders, ...gwConfig.headers };
-                        if (gwConfig.plugins) {
-                            for (const plugin of gwConfig.plugins) {
+                        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 (gwConfig.imports) {
-                            for (const mod of gwConfig.imports) {
+                        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 (gwConfig.providers) {
-                            for (const [token, providerConfig] of gwConfig.providers) {
+                        if (boundaryConfig.providers) {
+                            for (const [token, providerConfig] of boundaryConfig.providers) {
                                 this.app.container.provide(token, providerConfig);
                             }
                         }
@@ -570,7 +623,7 @@ class RouteScanner {
             ...(isControllerObj ? currentMod : {}),
             ...(mod.config || {}),
         };
-        // Fallback to global app.options.cors if neither gateway nor route specify it
+        // Fallback to global app.options.cors if neither boundary nor route specify it
         if (routeConfig.cors !== undefined)
             allCors = routeConfig.cors;
         else if (allCors === undefined && this.app.options.cors !== undefined)
@@ -586,7 +639,7 @@ class RouteScanner {
                 await this.app.pluginManager.register(plugin);
             }
         }
-        // Pass gateway features to controllers via metadata if necessary
+        // Pass boundary features to controllers via metadata if necessary
         const combinedFilters = [
             ...allFilters,
             ...(routeConfig.filters
@@ -640,13 +693,13 @@ class RouteScanner {
             const relFile = pathLib
                 .relative(process.cwd(), filePath)
                 .replace(/\\/g, '/');
-            const gwStr = activeGateways.length > 0
-                ? activeGateways
+            const boundaryStr = activeBoundaries.length > 0
+                ? activeBoundaries
                     .map((g) => pathLib.relative(process.cwd(), g).replace(/\\/g, '/'))
                     .join(' -> ') + ' -> '
                 : '';
             prefixMiddlewares.push((req, res, next) => {
-                this.app.log.debug(`[Request] ${req.method} ${req.path} -> ${gwStr}${relFile}`);
+                this.app.log.debug(`[Request] ${req.method} ${req.path} -> ${boundaryStr}${relFile}`);
                 next();
             });
         }
@@ -884,43 +937,13 @@ class RouteScanner {
             if (Object.keys(combinedMetadata).length > 0) {
                 schema.metadata = combinedMetadata;
             }
-            if (method === 'sse') {
-                const sseHandler = async (stream, rawReq) => {
-                    try {
-                        const ctx = {
-                            body: rawReq.body,
-                            query: rawReq.query,
-                            params: rawReq.params,
-                            headers: rawReq.headers,
-                            req: rawReq,
-                            res: undefined, // Res is not available in standard SSE after handshake
-                            app: this.app,
-                            resolve: (token) => this.app.resolve(token, rawReq._diCache),
-                            stream,
-                            ...rawReq,
-                        };
-                        await rc.handle(ctx);
-                    }
-                    catch (err) {
-                        if (onError) {
-                            await onError(err, rawReq, {});
-                        }
-                        else {
-                            console.error('[Exis SSE Error]', err);
-                        }
-                    }
-                };
-                router.sse(rc.path, ...routeMiddlewares, sseHandler);
+            if (Object.keys(schema).length > 0) {
+                ;
+                router[method](rc.path, ...routeMiddlewares, schema, superHandler);
             }
             else {
-                if (Object.keys(schema).length > 0) {
-                    ;
-                    router[method](rc.path, ...routeMiddlewares, schema, superHandler);
-                }
-                else {
-                    ;
-                    router[method](rc.path, ...routeMiddlewares, superHandler);
-                }
+                ;
+                router[method](rc.path, ...routeMiddlewares, superHandler);
             }
         }
         return router;