exisjs 0.1.3 → 0.1.5

package/dist/server/app.js

@@ -681,10 +681,39 @@ class App {
                 ];
                 const routeMeta = routeMetadataMap[route.handlerName] || {};
                 const finalHost = routeMeta.hosts || host;
-                if (route.schema || finalHost) {
-                    const schema = route.schema || {};
+                let schema = route.schema;
+                const paramMetadata = paramMetadataMap[route.handlerName] || [];
+                let extractedBodySchema = undefined;
+                let extractedQuerySchema = undefined;
+                for (const param of paramMetadata) {
+                    if (!param)
+                        continue;
+                    if (param.type === 'body') {
+                        const bodyPipe = param.pipes?.find((p) => p && typeof p.parse === 'function');
+                        if (bodyPipe)
+                            extractedBodySchema = bodyPipe;
+                    }
+                    if (param.type === 'query') {
+                        const queryPipe = param.pipes?.find((p) => p && typeof p.parse === 'function');
+                        if (queryPipe)
+                            extractedQuerySchema = queryPipe;
+                    }
+                }
+                const extractedResponseSchema = routeMeta.responseSchema;
+                if (schema ||
+                    finalHost ||
+                    extractedBodySchema ||
+                    extractedQuerySchema ||
+                    extractedResponseSchema) {
+                    schema = schema || {};
                     if (finalHost)
                         schema.host = finalHost;
+                    if (extractedBodySchema && !schema.body)
+                        schema.body = extractedBodySchema;
+                    if (extractedQuerySchema && !schema.query)
+                        schema.query = extractedQuerySchema;
+                    if (extractedResponseSchema && !schema.response)
+                        schema.response = extractedResponseSchema;
                     this.router[method](fullPath, ...allMiddlewares, schema, finalHandler);
                 }
                 else {
@@ -752,10 +781,8 @@ class App {
         return this._compiledPipeline;
     }
     // ─── Web Standard Fetch (Edge Runtime) & Inject ──────────────────────────────
-    fetch(request, env, ctx) {
-        // Dynamic require to avoid circular dependencies and top-level execution
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { handleFetch } = require('../adapters/fetch');
+    async fetch(request, env, ctx) {
+        const { handleFetch } = await Promise.resolve().then(() => __importStar(require('../adapters/fetch')));
         return handleFetch(this, request, env, ctx);
     }
     async inject(options) {
@@ -1033,42 +1060,42 @@ class App {
                 });
             },
         ];
-        await (0, router_1.runHandlers)(pipeline, req, res, async (err) => {
-            if (isAborted)
-                return;
-            if (err) {
-                this.log.error({ err }, 'Error during uWS WebSocket upgrade middleware');
+        this._executeWithContext(req, res, () => {
+            (0, router_1.runHandlers)(pipeline, req, res, async (err) => {
+                if (isAborted)
+                    return;
+                if (err) {
+                    this.log.error({ err }, 'Error during uWS WebSocket upgrade middleware');
+                    uwsRes.cork(() => {
+                        uwsRes.writeStatus('500 Internal Server Error');
+                        uwsRes.end();
+                    });
+                    return;
+                }
+                if (res.headersSent) {
+                    return; // Middleware sent an HTTP response
+                }
+                // We need to fetch headers directly from the shimReq.headers
+                const secWebSocketKey = shimReq.headers['sec-websocket-key'] || '';
+                const secWebSocketProtocol = shimReq.headers['sec-websocket-protocol'] || '';
+                const secWebSocketExtensions = shimReq.headers['sec-websocket-extensions'] || '';
+                // Prepare user data for the upgraded websocket
+                const userData = {
+                    req,
+                    res,
+                    exisWs: new socket_1.ExisWebSocket(null, req, this.wsServer), // the raw will be set to shim in open()
+                    finalHandler: matched.route.handlers[matched.route.handlers.length - 1],
+                };
+                this.wsServer.track(userData.exisWs);
+                req.ws = userData.exisWs;
                 uwsRes.cork(() => {
-                    uwsRes.writeStatus('500 Internal Server Error');
-                    uwsRes.end();
+                    uwsRes.upgrade(userData, secWebSocketKey, secWebSocketProtocol, secWebSocketExtensions, context);
+                });
+                Promise.resolve(userData.finalHandler(req, res, () => {
+                    /* noop */
+                })).catch((e) => {
+                    this.log.error({ err: e }, 'Error in uWS WebSocket handler');
                 });
-                return;
-            }
-            if (res.headersSent) {
-                return; // Middleware sent an HTTP response
-            }
-            // We need to fetch headers directly from the shimReq.headers
-            const secWebSocketKey = shimReq.headers['sec-websocket-key'] || '';
-            const secWebSocketProtocol = shimReq.headers['sec-websocket-protocol'] || '';
-            const secWebSocketExtensions = shimReq.headers['sec-websocket-extensions'] || '';
-            // Prepare user data for the upgraded websocket
-            const userData = {
-                req,
-                res,
-                exisWs: new socket_1.ExisWebSocket(null, req, this.wsServer), // the raw will be set to shim in open()
-                finalHandler: matched.route.handlers[matched.route.handlers.length - 1],
-            };
-            this.wsServer.track(userData.exisWs);
-            req.ws = userData.exisWs;
-            uwsRes.cork(() => {
-                uwsRes.upgrade(userData, secWebSocketKey, secWebSocketProtocol, secWebSocketExtensions, context);
-            });
-            // The open handler in createUwsApp will call finalHandler?
-            // Actually we should just execute the finalHandler here since upgrade succeeds immediately if we don't block
-            Promise.resolve(userData.finalHandler(req, res, () => {
-                /* noop */
-            })).catch((e) => {
-                this.log.error({ err: e }, 'Error in uWS WebSocket handler');
             });
         });
     }
@@ -1121,8 +1148,10 @@ class App {
                     onListen(address);
                 }
                 else {
-                    const url = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
-                    this.log.info({ url, env: this.options.env, backend: 'uws' }, `Server running at ${url} (uWebSockets.js)`);
+                    if (!process.env.__EXIS_DEV_SERVER && !process.env.__EXIS_CLI) {
+                        const url = `http://${host === '0.0.0.0' ? 'localhost' : host}:${port}`;
+                        this.log.info({ url, env: this.options.env, backend: 'uws' }, `Server running at ${url} (uWebSockets.js)`);
+                    }
                 }
                 if (this.options.env === 'production') {
                     const handleShutdown = async () => {
@@ -1274,10 +1303,19 @@ class App {
             : 'use --host 0.0.0.0 to expose';
         const readyMs = 125;
         const displayEnv = this.options.env || process.env.NODE_ENV || 'development';
+        const workerCount = process.env.__EXIS_CLUSTER_WORKERS;
+        const cluster = await Promise.resolve().then(() => __importStar(require('node:cluster')));
+        // In cluster mode, ONLY let Worker #1 print the banner so we don't spam the console 12 times
+        if (cluster.default.isWorker && cluster.default.worker?.id !== 1) {
+            return;
+        }
         console.log(`\n  ${c.primary}${c.bold}EXIS v${fwVersion}${c.reset}  ready in ${c.bold}${readyMs} ms${c.reset}\n`);
         console.log(`  ${c.white}➜${c.reset}  ${c.bold}Local:${c.reset}   ${c.blue}http://${displayHost}:${port}/${c.reset}`);
         console.log(`  ${c.white}➜${c.reset}  ${c.dim}Network:${c.reset} ${c.blue}${networkHost}/${c.reset}`);
         console.log(`  ${c.white}➜${c.reset}  ${c.dim}Environ:${c.reset} ${c.green}${displayEnv}${c.reset}`);
+        if (workerCount && Number(workerCount) > 1) {
+            console.log(`  ${c.white}➜${c.reset}  ${c.dim}Workers:${c.reset} ${c.magenta}${workerCount}${c.reset}`);
+        }
         console.log(`  ${c.white}➜${c.reset}  press ${c.bold}h + enter${c.reset} ${c.dim}to show help${c.reset}\n`);
     }
     // ─── Graceful Shutdown ────────────────────────────────────────────────────────
@@ -1477,8 +1515,14 @@ class App {
                 let url = (0, node_url_1.pathToFileURL)(manifestPath).href;
                 if (!isProd)
                     url += '?t=' + Date.now(); // cache bust for dev
-                const dynamicImport = new Function('specifier', 'return import(specifier)');
-                const mod = await dynamicImport(url);
+                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 manifest = mod.manifest;
                 if (Array.isArray(manifest)) {
                     for (const entry of manifest) {
@@ -1486,11 +1530,21 @@ class App {
                         const normalizedPath = path.resolve(root, filePath);
                         this.routeMap.set(normalizedPath, routePath);
                         const CONTROLLER_PREFIX = Symbol.for('exisjs:controller_prefix');
-                        const isController = (obj) => obj &&
+                        const isClassController = (obj) => obj &&
                             obj.prototype &&
                             obj.prototype[CONTROLLER_PREFIX] !== undefined;
+                        const unwrappedMod = routeMod.default && routeMod.default.default
+                            ? routeMod.default.default
+                            : routeMod.default
+                                ? routeMod.default
+                                : routeMod;
+                        const functionalControllerObj = unwrappedMod && unwrappedMod.__isController ? unwrappedMod : null;
                         const routerInstance = routeMod.router || routeMod.default || routeMod;
-                        if (isController(routerInstance)) {
+                        if (functionalControllerObj) {
+                            const router = this.compileFunctionalController(functionalControllerObj);
+                            this.mountRouteWithSource(routePath, router, normalizedPath);
+                        }
+                        else if (isClassController(routerInstance)) {
                             this.registerControllers([routerInstance], routePath);
                         }
                         else {
@@ -1502,7 +1556,10 @@ class App {
                 }
             }
         }
-        catch {
+        catch (err) {
+            if (err.code !== 'ENOENT') {
+                console.warn('exisjs: Failed to load routes manifest:', err.message);
+            }
             // Fall back to scanning the filesystem
         }
         const searchDirs = isProd
@@ -1647,10 +1704,17 @@ class App {
     }
     async mountRouteFile(filePath, routePath) {
         let mod;
-        const dynamicImport = new Function('specifier', 'return import(specifier)');
         try {
-            const url = (0, node_url_1.pathToFileURL)(filePath).href + '?t=' + Date.now();
-            mod = await dynamicImport(url);
+            const url = process.env.VITEST || process.env.NODE_ENV === 'test'
+                ? (0, node_url_1.pathToFileURL)(filePath).href
+                : (0, node_url_1.pathToFileURL)(filePath).href + '?t=' + Date.now();
+            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);
+            }
         }
         catch {
             // eslint-disable-next-line @typescript-eslint/no-require-imports
@@ -1688,10 +1752,28 @@ class App {
                 else if (await fs.stat(gwPathJs).catch(() => null))
                     targetGw = gwPathJs;
                 if (targetGw) {
-                    const url = (0, node_url_1.pathToFileURL)(targetGw).href + '?t=' + Date.now();
-                    // eslint-disable-next-line @typescript-eslint/no-require-imports
-                    const gwMod = await dynamicImport(url).catch(() => require(targetGw));
-                    const gwConfig = gwMod.default || gwMod;
+                    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;
+                    try {
+                        if (process.env.VITEST || process.env.NODE_ENV === 'test') {
+                            gwMod = await Promise.resolve(`${gwUrl}`).then(s => __importStar(require(s)));
+                        }
+                        else {
+                            const dynamicImportGw = new Function('specifier', 'return import(specifier)');
+                            gwMod = await dynamicImportGw(gwUrl);
+                        }
+                    }
+                    catch {
+                        // eslint-disable-next-line @typescript-eslint/no-require-imports
+                        gwMod = require(targetGw);
+                    }
+                    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)
@@ -1769,9 +1851,7 @@ class App {
                                 if (ms) {
                                     req.timeoutTimer = setTimeout(() => {
                                         if (!res.headersSent) {
-                                            res
-                                                .status(408)
-                                                .json({
+                                            res.status(408).json({
                                                 success: false,
                                                 error: {
                                                     code: 'REQUEST_TIMEOUT',
@@ -1818,45 +1898,80 @@ class App {
                 /* ignore */
             }
         }
-        if (!mod.config)
-            mod.config = {};
-        if (mod.config.middleware)
-            allMiddlewares.push(...mod.config.middleware);
-        if (mod.config.cors !== undefined)
-            allCors = mod.config.cors;
-        if (mod.config.headers)
-            allHeaders = { ...allHeaders, ...mod.config.headers };
-        if (mod.config.plugins) {
-            for (const plugin of mod.config.plugins) {
+        const currentMod = mod && mod.default && mod.default.default
+            ? mod.default.default
+            : mod && mod.default
+                ? mod.default
+                : mod;
+        const isControllerObj = currentMod && currentMod.__isController === true;
+        const routeConfig = {
+            ...(isControllerObj ? currentMod : {}),
+            ...(mod.config || {}),
+        };
+        // Fallback to global app.options.cors if neither gateway nor route specify it
+        if (routeConfig.cors !== undefined)
+            allCors = routeConfig.cors;
+        else if (allCors === undefined && this.options.cors !== undefined)
+            allCors = this.options.cors;
+        if (routeConfig.middleware)
+            allMiddlewares.push(...(Array.isArray(routeConfig.middleware)
+                ? routeConfig.middleware
+                : [routeConfig.middleware]));
+        if (routeConfig.headers)
+            allHeaders = { ...allHeaders, ...routeConfig.headers };
+        if (routeConfig.plugins) {
+            for (const plugin of routeConfig.plugins) {
                 await this.register(plugin);
             }
         }
-        // Inject Gateway features into module config for compileFunctionalController and OOP
-        mod.config.filters = [
+        // Pass gateway features to controllers via metadata if necessary
+        const combinedFilters = [
             ...allFilters,
-            ...(mod.config.filters
-                ? Array.isArray(mod.config.filters)
-                    ? mod.config.filters
-                    : [mod.config.filters]
+            ...(routeConfig.filters
+                ? Array.isArray(routeConfig.filters)
+                    ? routeConfig.filters
+                    : [routeConfig.filters]
                 : []),
         ];
-        mod.config.guards = [
+        const combinedGuards = [
             ...allGuards,
-            ...(mod.config.guards
-                ? Array.isArray(mod.config.guards)
-                    ? mod.config.guards
-                    : [mod.config.guards]
+            ...(routeConfig.guards
+                ? Array.isArray(routeConfig.guards)
+                    ? routeConfig.guards
+                    : [routeConfig.guards]
                 : []),
         ];
-        mod.config.interceptors = [
+        const combinedInterceptors = [
             ...allInterceptors,
-            ...(mod.config.interceptors
-                ? Array.isArray(mod.config.interceptors)
-                    ? mod.config.interceptors
-                    : [mod.config.interceptors]
+            ...(routeConfig.interceptors
+                ? Array.isArray(routeConfig.interceptors)
+                    ? routeConfig.interceptors
+                    : [routeConfig.interceptors]
                 : []),
         ];
-        mod.config.metadata = { ...allMetadata, ...(mod.config.metadata || {}) };
+        // Inject into the default export if it's a functional controller
+        if (mod.default && typeof mod.default === 'object') {
+            try {
+                if (!mod.default.filters)
+                    mod.default.filters = [];
+                mod.default.filters.push(...combinedFilters);
+                if (!mod.default.guards)
+                    mod.default.guards = [];
+                mod.default.guards.push(...combinedGuards);
+                if (!mod.default.interceptors)
+                    mod.default.interceptors = [];
+                mod.default.interceptors.push(...combinedInterceptors);
+                if (!mod.default.metadata)
+                    mod.default.metadata = {};
+                Object.assign(mod.default.metadata, {
+                    ...allMetadata,
+                    ...(routeConfig.metadata || {}),
+                });
+            }
+            catch {
+                // If mod.default is frozen, ignore
+            }
+        }
         const prefixMiddlewares = [];
         if (allCors !== undefined) {
             if (allCors === true)
@@ -1875,19 +1990,25 @@ class App {
         const isRouter = (obj) => obj && 'handle' in obj && 'get' in obj;
         const CONTROLLER_PREFIX = Symbol.for('exisjs:controller_prefix');
         const isController = (obj) => obj && obj.prototype && obj.prototype[CONTROLLER_PREFIX] !== undefined;
-        if (mod.default && mod.default.__isController) {
+        const unwrappedMod = mod && mod.default && mod.default.default
+            ? mod.default.default
+            : mod && mod.default
+                ? mod.default
+                : mod;
+        const functionalControllerObj = unwrappedMod && unwrappedMod.__isController ? unwrappedMod : null;
+        if (functionalControllerObj) {
             // ─── THE NEW PERFECT FUNCTIONAL CONTROLLER ───
-            const compiledRouter = this.compileFunctionalController(mod.default);
+            const compiledRouter = this.compileFunctionalController(functionalControllerObj);
             this.mountRouteWithSource(routePath, compiledRouter, filePath, prefixMiddlewares);
         }
         else if (mod.router && isRouter(mod.router)) {
             this.mountRouteWithSource(routePath, mod.router, filePath, prefixMiddlewares);
         }
-        else if (mod.default && isController(mod.default)) {
-            this.registerControllers([mod.default], routePath, prefixMiddlewares);
+        else if (unwrappedMod && isController(unwrappedMod)) {
+            this.registerControllers([unwrappedMod], routePath, prefixMiddlewares);
         }
-        else if (mod.default && isRouter(mod.default)) {
-            this.mountRouteWithSource(routePath, mod.default, filePath, prefixMiddlewares);
+        else if (unwrappedMod && isRouter(unwrappedMod)) {
+            this.mountRouteWithSource(routePath, unwrappedMod, filePath, prefixMiddlewares);
         }
         else if (isRouter(mod)) {
             this.mountRouteWithSource(routePath, mod, filePath, prefixMiddlewares);
@@ -1897,14 +2018,10 @@ class App {
         }
     }
     compileFunctionalController(config) {
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { Router } = require('../router/router');
-        // eslint-disable-next-line @typescript-eslint/no-require-imports
-        const { cors } = require('../middleware/middleware');
-        const router = new Router();
+        const router = new router_1.Router();
         const fileMiddleware = [];
         if (config.cors) {
-            fileMiddleware.push(config.cors === true ? cors({}) : cors(config.cors));
+            fileMiddleware.push(config.cors === true ? (0, middleware_1.cors)({}) : (0, middleware_1.cors)(config.cors));
         }
         if (config.middleware) {
             fileMiddleware.push(...(Array.isArray(config.middleware)
@@ -1926,7 +2043,7 @@ class App {
                 continue;
             const routeMiddlewares = [...fileMiddleware];
             if (rc.cors) {
-                routeMiddlewares.push(rc.cors === true ? cors({}) : cors(rc.cors));
+                routeMiddlewares.push(rc.cors === true ? (0, middleware_1.cors)({}) : (0, middleware_1.cors)(rc.cors));
             }
             if (rc.middleware) {
                 routeMiddlewares.push(...(Array.isArray(rc.middleware) ? rc.middleware : [rc.middleware]));
@@ -1947,9 +2064,7 @@ class App {
                             : guard.canActivate(req));
                         if (!allowed) {
                             if (res && !res.headersSent) {
-                                res
-                                    .status(403)
-                                    .json({
+                                res.status(403).json({
                                     success: false,
                                     error: { code: 'FORBIDDEN', message: 'Forbidden by Guard' },
                                 });
@@ -2078,9 +2193,11 @@ class App {
             }
             else {
                 if (Object.keys(schema).length > 0) {
+                    ;
                     router[method](rc.path, ...routeMiddlewares, schema, superHandler);
                 }
                 else {
+                    ;
                     router[method](rc.path, ...routeMiddlewares, superHandler);
                 }
             }