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

package/dist/esm-node/server/modernServer.mjs

@@ -0,0 +1,421 @@
+import __rslib_shim_module__ from "node:module";
+const require = /*#__PURE__*/ __rslib_shim_module__.createRequire(/*#__PURE__*/ (()=>import.meta.url)());
+import { time } from "@modern-js/runtime-utils/time";
+import { ROUTE_SPEC_FILE, fs, isPromise, isWebOnly, mime } from "@modern-js/utils";
+import { createServer } from "http";
+import path from "path";
+import { AGGRED_DIR, ERROR_DIGEST, ERROR_PAGE_TEXT, RUN_MODE, ServerReportTimings } from "../constants";
+import { createContext } from "../libs/context";
+import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "../libs/hook-api";
+import { resolveMfAssetCacheHeaders } from "../libs/mfCache";
+import { createProxyHandler } from "../libs/proxy";
+import { createRenderHandler } from "../libs/render/index.mjs";
+import * as __rspack_external__libs_render_reader_11828727 from "../libs/render/reader";
+import { RouteMatchManager } from "../libs/route";
+import { createStaticFileHandler, faviconFallbackHandler } from "../libs/serveFile";
+import { createErrorDocument, createMiddlewareCollecter, debug, getStaticReg, isRedirect, mergeExtension, noop } from "../utils.mjs";
+import { __webpack_require__ } from "../rslib-runtime.mjs";
+import * as __rspack_external_ignore_styles_9f5737c8 from "ignore-styles";
+__webpack_require__.add({
+    "ignore-styles" (module) {
+        module.exports = __rspack_external_ignore_styles_9f5737c8;
+    }
+});
+const SERVER_DIR = './server';
+class ModernServer {
+    async onInit(runner, app) {
+        this.runner = runner;
+        const { distDir, conf } = this;
+        this.initReader();
+        debug('final server conf', this.conf);
+        if (conf.bff?.proxy) {
+            const { handlers, handleUpgrade } = 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(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 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 = 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 createServer(handler);
+    }
+    initReader() {
+        this.reader.init();
+    }
+    async onServerChange({ filepath }) {
+        const { pwd } = this;
+        const { api, server } = AGGRED_DIR;
+        const apiPath = path.normalize(path.join(pwd, api));
+        const serverPath = path.normalize(path.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 = path.join(this.distDir, ROUTE_SPEC_FILE);
+        if (fs.existsSync(file)) {
+            const content = fs.readJSONSync(file);
+            return content.routes;
+        }
+        return [];
+    }
+    addHandler(handler) {
+        this.handlers.push(handler);
+    }
+    render404(context) {
+        context.error(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 } = createMiddlewareCollecter();
+        await runner.gather(collector);
+        const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
+        const serverDir = path.join(workDir, SERVER_DIR);
+        if (await fs.pathExists(path.join(serverDir)) && !onlyApi) {
+            const webExtension = mergeExtension(pluginWebExt);
+            this.frameWebHandler = await this.prepareWebHandler(webExtension);
+        }
+        if (!onlyWeb) {
+            const apiExtension = 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 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 = getStaticReg(this.conf.output, this.conf.html, prefix);
+        return createStaticFileHandler([
+            {
+                path: staticPathRegExp,
+                target: this.distDir
+            }
+        ], prefix);
+    }
+    setupMfAssetCacheMiddleware() {
+        return async (context, next)=>{
+            const headers = 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 = path.join(distDir, bundle);
+            if (fs.existsSync(filepath)) require(filepath);
+        });
+    }
+    createContext(req, res, options = {}) {
+        return 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 = time();
+        res.on('finish', ()=>{
+            const cost = end();
+            reporter.reportTiming(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 === RUN_MODE.FULL) {
+            const afterMatchContext = createAfterMatchContext(context, route.entryName);
+            const end = time();
+            await this.runner.afterMatch(afterMatchContext, {
+                onLast: noop
+            });
+            const cost = end();
+            cost && reporter.reportTiming(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 = createMiddlewareContext(context);
+            const end = time();
+            await this.frameWebHandler(middlewareContext);
+            const cost = end();
+            cost && reporter.reportTiming(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 === RUN_MODE.FULL) {
+            const afterRenderContext = createAfterRenderContext(context, response.toString());
+            const end = time();
+            await this.runner.afterRender(afterRenderContext, {
+                onLast: noop
+            });
+            const cost = end();
+            cost && reporter.reportTiming(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') && 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 (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', mime.contentType('html'));
+            return res.end(createErrorDocument(500, 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(ERROR_DIGEST.EINTER, err);
+        this.renderErrorPage(context, 500);
+    }
+    async renderErrorPage(context, status) {
+        const { res } = context;
+        context.status = status;
+        res.set('content-type', 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 = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT["500"];
+        context.res.end(createErrorDocument(status, text));
+    }
+    constructor({ pwd, config, routes, staticGenerate, logger, metrics, runMode, proxyTarget, appContext }){
+        this.handlers = [];
+        this.reader = __rspack_external__libs_render_reader_11828727;
+        this.loaderHandler = null;
+        this.frameWebHandler = null;
+        this.frameAPIHandler = null;
+        __webpack_require__("ignore-styles");
+        this.pwd = pwd;
+        this.distDir = path.resolve(pwd, config.output.path || 'dist');
+        this.workDir = this.distDir;
+        this.conf = config;
+        debug('server conf', this.conf);
+        this.logger = logger;
+        this.metrics = metrics;
+        this.router = new RouteMatchManager();
+        this.presetRoutes = routes;
+        this.proxyTarget = proxyTarget;
+        this.staticGenerate = staticGenerate || false;
+        this.runMode = runMode || RUN_MODE.FULL;
+        this.metaName = appContext?.metaName;
+    }
+}
+export { ModernServer };

package/dist/esm-node/server/modernServerSplit.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+const createProdServer = ()=>{
+    throw new Error('createProdServer from modernServerSplit is not available in this source runtime.');
+};
+export { createProdServer };

package/dist/esm-node/types.mjs

@@ -0,0 +1 @@
+import "node:module";

package/dist/esm-node/utils.mjs

@@ -0,0 +1,5 @@
+import "node:module";
+const debug = (...args)=>{
+    if (process.env.MODERN_DEBUG || process.env.DEBUG) console.log('[prod-server]', ...args);
+};
+export { debug };

package/dist/types/apply.d.ts

@@ -0,0 +1,6 @@
+import type { Server as NodeServer } from 'node:http';
+import type { Http2SecureServer } from 'node:http2';
+import { type ServerBase } from '@modern-js/server-core';
+import type { ProdServerOptions } from './types';
+export type ApplyPlugins = typeof applyPlugins;
+export declare function applyPlugins(serverBase: ServerBase, options: ProdServerOptions, nodeServer?: NodeServer | Http2SecureServer): Promise<void>;

package/dist/types/index.d.ts

@@ -0,0 +1,13 @@
+import { loadServerPlugins } from '@modern-js/server-core/node';
+import type { ProdServerOptions } from './types';
+export type { ServerPlugin } from '@modern-js/server-core';
+export { type ApplyPlugins, applyPlugins } from './apply';
+export type { TelemetryCanaryDecision, TelemetryQueueStats, TelemetrySloAlert, } from './libs/telemetry';
+export { createOtlpTelemetryExporter, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, hasEnabledTelemetryExporters, TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, } from './libs/telemetry';
+export type { BaseEnv, ProdServerOptions } from './types';
+export { loadServerPlugins };
+export declare const createProdServer: (options: ProdServerOptions) => Promise<(import("node:http").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | import("node:https").Server<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse> | import("node:http2").Http2SecureServer<typeof import("node:http").IncomingMessage, typeof import("node:http").ServerResponse, typeof import("node:http2").Http2ServerRequest, typeof import("node:http2").Http2ServerResponse>) & {
+    getRequestListener: () => ReturnType<(handler: import("@modern-js/server-core/dist/types/types").RequestHandler) => (req: import("@modern-js/types/server").NodeRequest, res: import("@modern-js/types/server").NodeResponse) => Promise<void>>;
+    getRequestHandler: () => import("@modern-js/server-core/dist/types/types").RequestHandler;
+}>;
+export default createProdServer;

package/dist/types/libs/metrics.d.ts

@@ -0,0 +1,8 @@
+type MetricTags = Record<string, unknown>;
+type Metrics = {
+    emitCounter: (name: string, value: number, prefix?: string, labels?: MetricTags) => void;
+    emitTimer: (name: string, value: number, prefix?: string, labels?: MetricTags) => void;
+    gauges: (labels: MetricTags, value: number, name: string, prefix?: string) => void;
+};
+export declare const metrics: Metrics;
+export {};

package/dist/types/libs/telemetry.d.ts

@@ -0,0 +1,2 @@
+export type { RuntimeFallbackSignalAuthConfig, RuntimeFallbackSignalRuntimeState, RuntimeFallbackSignalTrustContext, RuntimeFallbackSignalTrustPolicy, RuntimeSignalError, TelemetryCanaryDecision, TelemetryCanaryStatusSnapshot, TelemetryQueueStats, TelemetrySloAlert, } from '@modern-js/server-core';
+export { createOtlpTelemetryExporter, createRuntimeFallbackSignalRuntimeState, createRuntimeSignalError, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, DEFAULT_RUNTIME_STATUS_ENDPOINT, enforceRuntimeFallbackSignalAuthToken, enforceRuntimeFallbackSignalTrustPolicy, getRuntimeSignalErrorStatusCode, hasEnabledTelemetryExporters, normalizeRuntimeFallbackSignalAuthConfig, normalizeRuntimeFallbackTrustPolicy, parseRuntimeFallbackSignalPayloadFromRawBody, resolveRuntimeFallbackSignalEndpoint, TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, } from '@modern-js/server-core';

package/dist/types/netlify.d.ts

@@ -0,0 +1,3 @@
+import type { ProdServerOptions } from './types';
+export type { BaseEnv, ProdServerOptions } from './types';
+export declare const createNetlifyFunction: (options: ProdServerOptions) => Promise<(request: Request, context: unknown) => Response | Promise<Response>>;

package/dist/types/types.d.ts

@@ -0,0 +1,15 @@
+import type { CreateDefaultPluginsOptions, ServerBaseOptions, ServerPlugin } from '@modern-js/server-core';
+import type { Reporter } from '@modern-js/types';
+import type { Logger } from '@modern-js/utils';
+interface ProdServerExtraOptions {
+    serverConfigPath: string;
+    plugins?: ServerPlugin[];
+}
+export type ProdServerOptions = ServerBaseOptions & ProdServerExtraOptions & CreateDefaultPluginsOptions;
+export type BaseEnv = {
+    Variables: {
+        logger: Logger;
+        reporter: Reporter;
+    };
+};
+export {};

package/package.json

@@ -0,0 +1,79 @@
+{
+  "name": "@bleedingdev/modern-js-prod-server",
+  "description": "A Progressive React Framework for modern web development.",
+  "homepage": "https://github.com/BleedingDev/ultramodern.js#readme",
+  "bugs": {
+    "url": "https://github.com/BleedingDev/ultramodern.js/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/BleedingDev/ultramodern.js.git",
+    "directory": "packages/server/prod-server"
+  },
+  "license": "MIT",
+  "keywords": [
+    "react",
+    "framework",
+    "modern",
+    "modern.js"
+  ],
+  "version": "3.2.0-ultramodern.0",
+  "types": "./dist/types/index.d.ts",
+  "main": "./dist/cjs/index.js",
+  "exports": {
+    ".": {
+      "types": "./dist/types/index.d.ts",
+      "node": {
+        "import": "./dist/esm-node/index.mjs",
+        "require": "./dist/cjs/index.js"
+      },
+      "default": "./dist/cjs/index.js"
+    },
+    "./netlify": {
+      "types": "./dist/types/netlify.d.ts",
+      "node": {
+        "import": "./dist/esm-node/netlify.mjs",
+        "require": "./dist/cjs/netlify.js"
+      },
+      "default": "./dist/cjs/netlify.js"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      ".": [
+        "./dist/types/index.d.ts"
+      ],
+      "netlify": [
+        "./dist/types/netlify.d.ts"
+      ]
+    }
+  },
+  "dependencies": {
+    "@swc/helpers": "^0.5.21",
+    "@modern-js/runtime-utils": "npm:@bleedingdev/modern-js-runtime-utils@3.2.0-ultramodern.0",
+    "@modern-js/server-core": "npm:@bleedingdev/modern-js-server-core@3.2.0-ultramodern.0",
+    "@modern-js/utils": "npm:@bleedingdev/modern-js-utils@3.2.0-ultramodern.0"
+  },
+  "devDependencies": {
+    "@rslib/core": "0.21.5",
+    "@types/merge-deep": "^3.0.3",
+    "@types/node": "^25.8.0",
+    "@typescript/native-preview": "7.0.0-dev.20260516.1",
+    "lint-staged": "~17.0.5",
+    "@modern-js/types": "npm:@bleedingdev/modern-js-types@3.2.0-ultramodern.0",
+    "@scripts/rstest-config": "2.66.0"
+  },
+  "sideEffects": [],
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "rslib build",
+    "dev": "rslib build --watch",
+    "test": "rstest --passWithNoTests"
+  }
+}

package/rslib.config.mts

@@ -0,0 +1,4 @@
+import { rslibConfig } from '@modern-js/rslib';
+import { defineConfig } from '@rslib/core';
+
+export default defineConfig(rslibConfig);

package/rstest.config.mts

@@ -0,0 +1,7 @@
+import { withTestPreset } from '@scripts/rstest-config';
+
+export default withTestPreset({
+  root: __dirname,
+  testEnvironment: 'node',
+  globals: true,
+});