@bleedingdev/modern-js-prod-server 3.2.0-ultramodern.0

package/dist/cjs/server/modernServer.js

@@ -0,0 +1,472 @@
+"use strict";
+var __webpack_modules__ = {
+    "ignore-styles" (module) {
+        module.exports = require("ignore-styles");
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+(()=>{
+    __webpack_require__.n = (module)=>{
+        var getter = module && module.__esModule ? ()=>module['default'] : ()=>module;
+        __webpack_require__.d(getter, {
+            a: getter
+        });
+        return getter;
+    };
+})();
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+(()=>{
+    __webpack_require__.r(__webpack_exports__);
+    __webpack_require__.d(__webpack_exports__, {
+        ModernServer: ()=>ModernServer
+    });
+    const time_namespaceObject = require("@modern-js/runtime-utils/time");
+    const utils_namespaceObject = require("@modern-js/utils");
+    const external_http_namespaceObject = require("http");
+    const external_path_namespaceObject = require("path");
+    var external_path_default = /*#__PURE__*/ __webpack_require__.n(external_path_namespaceObject);
+    const external_constants_namespaceObject = require("../constants");
+    const context_namespaceObject = require("../libs/context");
+    const hook_api_namespaceObject = require("../libs/hook-api");
+    const mfCache_namespaceObject = require("../libs/mfCache");
+    const proxy_namespaceObject = require("../libs/proxy");
+    const index_js_namespaceObject = require("../libs/render/index.js");
+    const reader_namespaceObject = require("../libs/render/reader");
+    const route_namespaceObject = require("../libs/route");
+    const serveFile_namespaceObject = require("../libs/serveFile");
+    const external_utils_js_namespaceObject = require("../utils.js");
+    const SERVER_DIR = './server';
+    class ModernServer {
+        async onInit(runner, app) {
+            this.runner = runner;
+            const { distDir, conf } = this;
+            this.initReader();
+            (0, external_utils_js_namespaceObject.debug)('final server conf', this.conf);
+            if (conf.bff?.proxy) {
+                const { handlers, handleUpgrade } = (0, proxy_namespaceObject.createProxyHandler)(conf.bff.proxy);
+                app && handleUpgrade(app);
+                handlers.forEach((handler)=>{
+                    this.addHandler(handler);
+                });
+            }
+            app?.on('close', ()=>{
+                this.reader.close();
+            });
+            const usageRoutes = this.filterRoutes(this.getRoutes());
+            this.router.reset(usageRoutes);
+            this.warmupSSRBundle();
+            await this.prepareFrameHandler();
+            await this.prepareLoaderHandler(usageRoutes, distDir);
+            this.routeRenderHandler = this.getRenderHandler();
+            await this.setupBeforeProdMiddleware();
+            this.addHandler(this.setupMfAssetCacheMiddleware());
+            this.addHandler(this.setupStaticMiddleware(this.conf.output?.assetPrefix));
+            this.addHandler(serveFile_namespaceObject.faviconFallbackHandler);
+            this.addHandler(this.routeHandler.bind(this));
+            this.compose();
+        }
+        getRenderHandler() {
+            const { distDir, staticGenerate, conf, metaName } = this;
+            const ssrConfig = this.conf.server?.ssr;
+            const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
+            return (0, index_js_namespaceObject.createRenderHandler)({
+                distDir,
+                staticGenerate,
+                forceCSR,
+                conf: this.conf,
+                nonce: conf.security?.nonce,
+                metaName
+            });
+        }
+        onRepack(_) {}
+        getRequestHandler() {
+            return this.requestHandler.bind(this);
+        }
+        async render(req, res, url) {
+            req.logger = req.logger || this.logger;
+            req.metrics = req.metrics || this.metrics;
+            const context = (0, context_namespaceObject.createContext)(req, res, {
+                metaName: this.metaName
+            });
+            const matched = this.router.match(url || context.path);
+            if (!matched) return null;
+            res.statusCode = 200;
+            const route = matched.generate(context.url);
+            const result = await this.handleWeb(context, route);
+            if (!result) return null;
+            if (result.contentStream) return result.contentStream;
+            return result.content.toString();
+        }
+        async createHTTPServer(handler) {
+            return (0, external_http_namespaceObject.createServer)(handler);
+        }
+        initReader() {
+            this.reader.init();
+        }
+        async onServerChange({ filepath }) {
+            const { pwd } = this;
+            const { api, server } = external_constants_namespaceObject.AGGRED_DIR;
+            const apiPath = external_path_default().normalize(external_path_default().join(pwd, api));
+            const serverPath = external_path_default().normalize(external_path_default().join(pwd, server));
+            const onlyApi = filepath.startsWith(apiPath);
+            const onlyWeb = filepath.startsWith(serverPath);
+            await this.prepareFrameHandler({
+                onlyWeb,
+                onlyApi
+            });
+        }
+        getRoutes() {
+            if (this.presetRoutes) return this.presetRoutes;
+            const file = external_path_default().join(this.distDir, utils_namespaceObject.ROUTE_SPEC_FILE);
+            if (utils_namespaceObject.fs.existsSync(file)) {
+                const content = utils_namespaceObject.fs.readJSONSync(file);
+                return content.routes;
+            }
+            return [];
+        }
+        addHandler(handler) {
+            this.handlers.push(handler);
+        }
+        render404(context) {
+            context.error(external_constants_namespaceObject.ERROR_DIGEST.ENOTF, '404 Not Found');
+            this.renderErrorPage(context, 404);
+        }
+        async prepareLoaderHandler(specs, distDir) {
+            const { runner } = this;
+            const handler = await runner.prepareLoaderHandler({
+                serverRoutes: specs,
+                distDir
+            }, {
+                onLast: ()=>null
+            });
+            this.loaderHandler = handler;
+        }
+        async prepareFrameHandler(options) {
+            const { workDir, runner } = this;
+            const { onlyApi, onlyWeb } = options || {};
+            const { getMiddlewares, ...collector } = (0, external_utils_js_namespaceObject.createMiddlewareCollecter)();
+            await runner.gather(collector);
+            const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
+            const serverDir = external_path_default().join(workDir, SERVER_DIR);
+            if (await utils_namespaceObject.fs.pathExists(external_path_default().join(serverDir)) && !onlyApi) {
+                const webExtension = (0, external_utils_js_namespaceObject.mergeExtension)(pluginWebExt);
+                this.frameWebHandler = await this.prepareWebHandler(webExtension);
+            }
+            if (!onlyWeb) {
+                const apiExtension = (0, external_utils_js_namespaceObject.mergeExtension)(pluginAPIExt);
+                this.frameAPIHandler = await this.prepareAPIHandler(apiExtension);
+            }
+        }
+        async prepareWebHandler(extension) {
+            const { workDir, runner } = this;
+            const handler = await runner.prepareWebServer({
+                pwd: workDir,
+                config: extension
+            }, {
+                onLast: ()=>null
+            });
+            return handler;
+        }
+        async prepareAPIHandler(extension) {
+            const { workDir, runner, conf } = this;
+            const { bff } = conf;
+            const prefix = bff?.prefix || '/api';
+            const webOnly = await (0, utils_namespaceObject.isWebOnly)();
+            if (webOnly && 'development' === process.env.NODE_ENV) return (req, res)=>{
+                res.setHeader('Content-Type', 'text/plain');
+                res.end(JSON.stringify(''));
+            };
+            return runner.prepareApiServer({
+                pwd: workDir,
+                config: extension,
+                prefix: Array.isArray(prefix) ? prefix[0] : prefix,
+                httpMethodDecider: bff?.httpMethodDecider,
+                render: this.render.bind(this)
+            }, {
+                onLast: ()=>null
+            });
+        }
+        filterRoutes(routes) {
+            return routes;
+        }
+        async setupBeforeProdMiddleware() {
+            const { conf, runner } = this;
+            const preMiddleware = await runner.beforeProdServer(conf);
+            preMiddleware.flat().forEach((mid)=>{
+                this.addHandler(mid);
+            });
+        }
+        setupStaticMiddleware(prefix) {
+            const staticPathRegExp = (0, external_utils_js_namespaceObject.getStaticReg)(this.conf.output, this.conf.html, prefix);
+            return (0, serveFile_namespaceObject.createStaticFileHandler)([
+                {
+                    path: staticPathRegExp,
+                    target: this.distDir
+                }
+            ], prefix);
+        }
+        setupMfAssetCacheMiddleware() {
+            return async (context, next)=>{
+                const headers = (0, mfCache_namespaceObject.resolveMfAssetCacheHeaders)(context.url, context.query);
+                if (headers) for (const [key, value] of Object.entries(headers))context.res.setHeader(key, value);
+                await next();
+            };
+        }
+        async handleAPI(context) {
+            const { req, res } = context;
+            if (!this.frameAPIHandler) throw new Error('can not found api handler');
+            await this.frameAPIHandler(req, res);
+        }
+        async handleWeb(context, route) {
+            const { res } = context;
+            if (this.loaderHandler) {
+                await this.loaderHandler(context);
+                if (this.isSend(res)) return null;
+            }
+            context.setParams(route.params);
+            context.setServerData('router', {
+                baseUrl: route.urlPath,
+                params: route.params
+            });
+            if (route.responseHeaders) Object.keys(route.responseHeaders).forEach((key)=>{
+                const value = route.responseHeaders[key];
+                if (value) context.res.setHeader(key, value);
+            });
+            const renderResult = await this.routeRenderHandler({
+                ctx: context,
+                route,
+                runner: this.runner
+            });
+            if (!renderResult) {
+                this.render404(context);
+                return null;
+            }
+            if (renderResult.redirect) {
+                this.redirect(res, renderResult.content, renderResult.statusCode);
+                return null;
+            }
+            if (this.isSend(res)) return null;
+            res.set('content-type', renderResult.contentType);
+            return renderResult;
+        }
+        async proxy() {
+            return null;
+        }
+        warmupSSRBundle() {
+            const { distDir } = this;
+            const bundles = this.router.getBundles();
+            bundles.forEach((bundle)=>{
+                const filepath = external_path_default().join(distDir, bundle);
+                if (utils_namespaceObject.fs.existsSync(filepath)) require(filepath);
+            });
+        }
+        createContext(req, res, options = {}) {
+            return (0, context_namespaceObject.createContext)(req, res, options);
+        }
+        async routeHandler(context) {
+            const { res, reporter } = context;
+            const matched = this.router.match(context.path);
+            if (!matched) return void this.render404(context);
+            await reporter.init({
+                match: matched
+            });
+            const end = (0, time_namespaceObject.time)();
+            res.on('finish', ()=>{
+                const cost = end();
+                reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
+            });
+            let route = matched.generate(context.url);
+            if (route.isApi) return void await this.handleAPI(context);
+            if (route.entryName && this.runMode === external_constants_namespaceObject.RUN_MODE.FULL) {
+                const afterMatchContext = (0, hook_api_namespaceObject.createAfterMatchContext)(context, route.entryName);
+                const end = (0, time_namespaceObject.time)();
+                await this.runner.afterMatch(afterMatchContext, {
+                    onLast: external_utils_js_namespaceObject.noop
+                });
+                const cost = end();
+                cost && reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
+                if (this.isSend(res)) return;
+                const { current, url, status } = afterMatchContext.router;
+                if (url) return void this.redirect(res, url, status);
+                if (route.entryName !== current) {
+                    const matched = this.router.matchEntry(current);
+                    if (!matched) return void this.render404(context);
+                    route = matched.generate(context.url);
+                }
+            }
+            if (this.frameWebHandler) {
+                res.locals = res.locals || {};
+                const middlewareContext = (0, hook_api_namespaceObject.createMiddlewareContext)(context);
+                const end = (0, time_namespaceObject.time)();
+                await this.frameWebHandler(middlewareContext);
+                const cost = end();
+                cost && reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_MIDDLEWARE, cost);
+                res.locals = {
+                    ...res.locals,
+                    ...middlewareContext.response.locals
+                };
+                if (this.isSend(res)) return;
+            }
+            const renderResult = await this.handleWeb(context, route);
+            if (!renderResult) return;
+            const { contentStream: responseStream } = renderResult;
+            let { content: response } = renderResult;
+            if (route.entryName && responseStream) return void responseStream.pipe(res);
+            if (route.entryName && this.runMode === external_constants_namespaceObject.RUN_MODE.FULL) {
+                const afterRenderContext = (0, hook_api_namespaceObject.createAfterRenderContext)(context, response.toString());
+                const end = (0, time_namespaceObject.time)();
+                await this.runner.afterRender(afterRenderContext, {
+                    onLast: external_utils_js_namespaceObject.noop
+                });
+                const cost = end();
+                cost && reporter.reportTiming(external_constants_namespaceObject.ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost);
+                if (this.isSend(res)) return;
+                response = afterRenderContext.template.get();
+            }
+            res.end(response);
+        }
+        isSend(res) {
+            if (res.modernFlushedHeaders) {
+                if (res.writableFinished) return true;
+            } else if (res.headersSent) return true;
+            if (res.getHeader('Location') && (0, external_utils_js_namespaceObject.isRedirect)(res.statusCode)) {
+                res.end();
+                return true;
+            }
+            return false;
+        }
+        compose() {
+            const { handlers } = this;
+            if (!Array.isArray(handlers)) throw new TypeError('Middleware stack must be an array!');
+            for (const fn of handlers)if ('function' != typeof fn) throw new TypeError('Middleware must be composed of functions!');
+            this._handler = (context, next)=>{
+                let i = 0;
+                const dispatch = (error)=>{
+                    if (error) return this.onError(context, error);
+                    const handler = handlers[i++];
+                    if (!handler) return next();
+                    try {
+                        const result = handler(context, dispatch);
+                        if ((0, utils_namespaceObject.isPromise)(result)) return result.catch(onError);
+                    } catch (e) {
+                        return onError(e);
+                    }
+                };
+                const onError = (err)=>{
+                    this.onError(context, err);
+                };
+                return dispatch();
+            };
+        }
+        requestHandler(req, res, next = ()=>{}) {
+            res.statusCode = 200;
+            req.logger = req.logger || this.logger;
+            req.metrics = req.metrics || this.metrics;
+            let context;
+            try {
+                context = this.createContext(req, res, {
+                    metaName: this.metaName
+                });
+            } catch (e) {
+                this.logger.error(e);
+                res.statusCode = 500;
+                res.setHeader('content-type', utils_namespaceObject.mime.contentType('html'));
+                return res.end((0, external_utils_js_namespaceObject.createErrorDocument)(500, external_constants_namespaceObject.ERROR_PAGE_TEXT["500"]));
+            }
+            try {
+                return this._handler(context, next);
+            } catch (err) {
+                return this.onError(context, err);
+            }
+        }
+        redirect(res, url, status = 302) {
+            res.set('Location', url);
+            res.statusCode = status;
+            res.end();
+        }
+        onError(context, err) {
+            context.error(external_constants_namespaceObject.ERROR_DIGEST.EINTER, err);
+            this.renderErrorPage(context, 500);
+        }
+        async renderErrorPage(context, status) {
+            const { res } = context;
+            context.status = status;
+            res.set('content-type', utils_namespaceObject.mime.contentType('html'));
+            const statusPage = `/${status}`;
+            const customErrorPage = "/_error";
+            const matched = this.router.match(statusPage) || this.router.match(customErrorPage);
+            if (matched) {
+                const route = matched.generate(context.url);
+                const { entryName } = route;
+                if (entryName === status.toString() || '_error' === entryName) try {
+                    const file = await this.routeRenderHandler({
+                        route,
+                        ctx: context,
+                        runner: this.runner
+                    });
+                    if (file) return void context.res.end(file.content);
+                } catch (e) {}
+            }
+            const text = external_constants_namespaceObject.ERROR_PAGE_TEXT[status] || external_constants_namespaceObject.ERROR_PAGE_TEXT["500"];
+            context.res.end((0, external_utils_js_namespaceObject.createErrorDocument)(status, text));
+        }
+        constructor({ pwd, config, routes, staticGenerate, logger, metrics, runMode, proxyTarget, appContext }){
+            this.handlers = [];
+            this.reader = reader_namespaceObject;
+            this.loaderHandler = null;
+            this.frameWebHandler = null;
+            this.frameAPIHandler = null;
+            __webpack_require__("ignore-styles");
+            this.pwd = pwd;
+            this.distDir = external_path_default().resolve(pwd, config.output.path || 'dist');
+            this.workDir = this.distDir;
+            this.conf = config;
+            (0, external_utils_js_namespaceObject.debug)('server conf', this.conf);
+            this.logger = logger;
+            this.metrics = metrics;
+            this.router = new route_namespaceObject.RouteMatchManager();
+            this.presetRoutes = routes;
+            this.proxyTarget = proxyTarget;
+            this.staticGenerate = staticGenerate || false;
+            this.runMode = runMode || external_constants_namespaceObject.RUN_MODE.FULL;
+            this.metaName = appContext?.metaName;
+        }
+    }
+})();
+exports.ModernServer = __webpack_exports__.ModernServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "ModernServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/server/modernServerSplit.js

@@ -0,0 +1,38 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    createProdServer: ()=>createProdServer
+});
+const createProdServer = ()=>{
+    throw new Error('createProdServer from modernServerSplit is not available in this source runtime.');
+};
+exports.createProdServer = __webpack_exports__.createProdServer;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "createProdServer"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/types.js

@@ -0,0 +1,18 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+for(var __rspack_i in __webpack_exports__)exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/cjs/utils.js

@@ -0,0 +1,38 @@
+"use strict";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.d = (exports1, definition)=>{
+        for(var key in definition)if (__webpack_require__.o(definition, key) && !__webpack_require__.o(exports1, key)) Object.defineProperty(exports1, key, {
+            enumerable: true,
+            get: definition[key]
+        });
+    };
+})();
+(()=>{
+    __webpack_require__.o = (obj, prop)=>Object.prototype.hasOwnProperty.call(obj, prop);
+})();
+(()=>{
+    __webpack_require__.r = (exports1)=>{
+        if ("u" > typeof Symbol && Symbol.toStringTag) Object.defineProperty(exports1, Symbol.toStringTag, {
+            value: 'Module'
+        });
+        Object.defineProperty(exports1, '__esModule', {
+            value: true
+        });
+    };
+})();
+var __webpack_exports__ = {};
+__webpack_require__.r(__webpack_exports__);
+__webpack_require__.d(__webpack_exports__, {
+    debug: ()=>debug
+});
+const debug = (...args)=>{
+    if (process.env.MODERN_DEBUG || process.env.DEBUG) console.log('[prod-server]', ...args);
+};
+exports.debug = __webpack_exports__.debug;
+for(var __rspack_i in __webpack_exports__)if (-1 === [
+    "debug"
+].indexOf(__rspack_i)) exports[__rspack_i] = __webpack_exports__[__rspack_i];
+Object.defineProperty(exports, '__esModule', {
+    value: true
+});

package/dist/esm/apply.mjs

@@ -0,0 +1,63 @@
+import { ErrorDigest, createDefaultPlugins, createErrorHtml, faviconPlugin, injectConfigMiddlewarePlugin, onError, renderPlugin } from "@modern-js/server-core";
+import { injectNodeSeverPlugin, injectResourcePlugin, injectRscManifestPlugin, loadCacheConfig, serverStaticPlugin } from "@modern-js/server-core/node";
+import { createLogger, isProd, logger } from "@modern-js/utils";
+function getLogger(_) {
+    if (process.env.DEBUG || 'production' === process.env.NODE_ENV) return createLogger({
+        level: process.env.MODERN_SERVER_LOG_LEVEL || 'verbose'
+    });
+    return createLogger();
+}
+async function applyPlugins(serverBase, options, nodeServer) {
+    const { pwd, appContext, config, logger: optLogger, serverConfig } = options;
+    const enableRsc = config.server?.rsc ?? serverConfig?.server?.rsc ?? false;
+    const serverErrorHandler = options.serverConfig?.onError;
+    const loadCachePwd = isProd() ? pwd : appContext.appDirectory || pwd;
+    const cacheConfig = await loadCacheConfig(loadCachePwd);
+    serverBase.notFound((c)=>{
+        const monitors = c.get('monitors');
+        onError(ErrorDigest.ENOTF, '404 not found', monitors, c.req.raw);
+        return c.html(createErrorHtml(404), 404);
+    });
+    serverBase.onError(async (err, c)=>{
+        const monitors = c.get('monitors');
+        onError(ErrorDigest.EINTER, err, monitors, c.req.raw);
+        if (serverErrorHandler) try {
+            const result = await serverErrorHandler(err, c);
+            if (result instanceof Response) return result;
+        } catch (configError) {
+            logger.error(`Error in serverConfig.onError handler: ${configError}`);
+        }
+        const bffPrefix = config.bff?.prefix || '/api';
+        const bffPrefixList = Array.isArray(bffPrefix) ? bffPrefix : [
+            bffPrefix
+        ];
+        const isApiPath = bffPrefixList.some((prefix)=>c.req.path.startsWith(prefix));
+        if (isApiPath) return c.json({
+            message: err?.message || '[BFF] Internal Server Error'
+        }, err?.status || 500);
+        return c.html(createErrorHtml(500), 500);
+    });
+    const loggerOptions = config.server.logger;
+    const { middlewares, renderMiddlewares } = options.serverConfig || {};
+    const plugins = [
+        ...nodeServer ? [
+            injectNodeSeverPlugin({
+                nodeServer
+            })
+        ] : [],
+        ...createDefaultPlugins({
+            cacheConfig,
+            staticGenerate: options.staticGenerate,
+            logger: false === loggerOptions ? false : optLogger || getLogger(loggerOptions)
+        }),
+        injectConfigMiddlewarePlugin(middlewares, renderMiddlewares),
+        ...options.plugins || [],
+        injectResourcePlugin(),
+        injectRscManifestPlugin(enableRsc),
+        serverStaticPlugin(),
+        faviconPlugin(),
+        renderPlugin()
+    ];
+    serverBase.addPlugins(plugins);
+}
+export { applyPlugins };

package/dist/esm/index.mjs

@@ -0,0 +1,26 @@
+import { createServerBase } from "@modern-js/server-core";
+import { createNodeServer, loadServerCliConfig, loadServerEnv, loadServerPlugins, loadServerRuntimeConfig } from "@modern-js/server-core/node";
+import { applyPlugins } from "./apply.mjs";
+const createProdServer = async (options)=>{
+    await loadServerEnv(options);
+    const serverBaseOptions = options;
+    const serverCliConfig = 'production' === process.env.NODE_ENV ? loadServerCliConfig(options.pwd, options.config) : options.config;
+    if (serverCliConfig) serverBaseOptions.config = serverCliConfig;
+    const serverRuntimeConfig = await loadServerRuntimeConfig(options.serverConfigPath);
+    if (serverRuntimeConfig) {
+        serverBaseOptions.serverConfig = serverRuntimeConfig;
+        serverBaseOptions.plugins = [
+            ...serverRuntimeConfig.plugins || [],
+            ...options.plugins || []
+        ];
+    }
+    const server = createServerBase(serverBaseOptions);
+    const nodeServer = await createNodeServer(server.handle.bind(server));
+    await applyPlugins(server, options, nodeServer);
+    await server.init();
+    return nodeServer;
+};
+const src = createProdServer;
+export { TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, createOtlpTelemetryExporter, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, hasEnabledTelemetryExporters } from "./libs/telemetry.mjs";
+export default src;
+export { applyPlugins, createProdServer, loadServerPlugins };

package/dist/esm/libs/contractGateAutopilot.mjs

@@ -0,0 +1 @@
+export { ContractGateAutopilot } from "@modern-js/server-core";

package/dist/esm/libs/loadConfig.mjs

@@ -0,0 +1,22 @@
+import { compatibleRequire, fs, lodash } from "@modern-js/utils";
+import { parse } from "flatted";
+import path from "path";
+const getServerConfigPath = (distDirectory, serverConfigFile)=>{
+    const fileName = serverConfigFile || 'server.js';
+    return path.join(distDirectory, fileName);
+};
+const requireConfig = (serverConfigPath)=>{
+    if (fs.pathExistsSync(serverConfigPath)) return compatibleRequire(serverConfigPath) || {};
+    return {};
+};
+const loadConfig = ({ cliConfig, serverConfig, resolvedConfigPath })=>{
+    let outputConfig = {};
+    if (fs.pathExistsSync(resolvedConfigPath)) try {
+        const content = fs.readFileSync(resolvedConfigPath, 'utf8');
+        outputConfig = parse(content) || {};
+    } catch (_error) {
+        outputConfig = {};
+    }
+    return lodash.merge({}, outputConfig, serverConfig || {}, cliConfig || {});
+};
+export { getServerConfigPath, loadConfig, requireConfig };