@modern-js/server-core 2.69.4 → 3.0.0-alpha.0

package/dist/esm-node/plugins/render/render.mjs

@@ -0,0 +1,226 @@
+import * as __rspack_external__modern_js_runtime_utils_router_2aa8d96f from "@modern-js/runtime-utils/router";
+import { cutNameByHyphen } from "@modern-js/utils/universal";
+import { TrieRouter } from "hono/router/trie-router";
+import { X_MODERNJS_RENDER } from "../../constants.mjs";
+import { ErrorDigest, createErrorHtml, getPathname, getRuntimeEnv, parseHeaders, parseQuery, sortRoutes, uniqueKeyByRoute } from "../../utils/index.mjs";
+import { csrRscRender } from "./csrRscRender.mjs";
+import { dataHandler } from "./dataHandler.mjs";
+import { renderRscHandler } from "./renderRscHandler.mjs";
+import { serverActionHandler } from "./serverActionHandler.mjs";
+import { ssrRender } from "./ssrRender.mjs";
+var __webpack_modules__ = {
+    "@modern-js/runtime-utils/router" (module) {
+        module.exports = __rspack_external__modern_js_runtime_utils_router_2aa8d96f;
+    }
+};
+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;
+}
+const DYNAMIC_ROUTE_REG = /\/:./;
+function getRouter(routes) {
+    const dynamicRoutes = [];
+    const normalRoutes = [];
+    routes.forEach((route)=>{
+        if (DYNAMIC_ROUTE_REG.test(route.urlPath)) dynamicRoutes.push(route);
+        else normalRoutes.push(route);
+    });
+    const finalRoutes = [
+        ...normalRoutes.sort(sortRoutes),
+        ...dynamicRoutes.sort(sortRoutes)
+    ];
+    const router = new TrieRouter();
+    for (const route of finalRoutes){
+        const { urlPath: originUrlPath } = route;
+        const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
+        router.add('*', urlPath, route);
+    }
+    return router;
+}
+function matchRoute(router, pathname, entryName) {
+    const matched = router.match('*', pathname);
+    if (entryName && matched[0].length > 1) {
+        const matches = matched[0];
+        const result = matches.find(([route])=>route.entryName === entryName);
+        return result || [];
+    }
+    {
+        const result = matched[0][0];
+        return result || [];
+    }
+}
+function getHeadersWithoutCookie(headers) {
+    const _headers = {
+        ...headers,
+        cookie: void 0
+    };
+    delete _headers.cookie;
+    return _headers;
+}
+async function createRender({ routes, pwd, metaName, staticGenerate, cacheConfig, forceCSR, forceCSRMap, config, onFallback }) {
+    const router = getRouter(routes);
+    return async (req, { monitors, nodeReq, templates, serverManifest, rscClientManifest, rscSSRManifest, rscServerManifest, locals, matchEntryName, matchPathname, loaderContext, contextForceCSR, reporter })=>{
+        const forMatchpathname = matchPathname ?? getPathname(req);
+        const [routeInfo, params] = matchRoute(router, forMatchpathname, matchEntryName);
+        const framework = cutNameByHyphen(metaName || 'modern-js');
+        const fallbackHeader = `x-${framework}-ssr-fallback`;
+        let fallbackReason = null;
+        const fallbackWrapper = async (reason, error)=>{
+            fallbackReason = reason;
+            return onFallback?.(reason, error);
+        };
+        if (!routeInfo) return new Response(createErrorHtml(404), {
+            status: 404,
+            headers: {
+                'content-type': 'text/html; charset=UTF-8'
+            }
+        });
+        const html = templates[uniqueKeyByRoute(routeInfo)];
+        if (!html) return new Response(createErrorHtml(404), {
+            status: 404,
+            headers: {
+                'content-type': 'text/html; charset=UTF-8'
+            }
+        });
+        const finalForceCSR = routeInfo.entryName ? forceCSRMap?.get(routeInfo.entryName) ?? forceCSR : forceCSR;
+        const renderMode = await getRenderMode(req, fallbackHeader, routeInfo.isSSR, finalForceCSR, nodeReq, fallbackWrapper, contextForceCSR);
+        const headerData = parseHeaders(req);
+        const onError = (e, key)=>{
+            monitors?.error(`SSR Error - ${key || (e instanceof Error ? e.name : e)}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, forMatchpathname, getHeadersWithoutCookie(headerData));
+        };
+        const onTiming = (name, dur)=>{
+            monitors?.timing(name, dur, 'SSR');
+        };
+        const renderOptions = {
+            pwd,
+            html,
+            routeInfo,
+            staticGenerate: staticGenerate || false,
+            config,
+            nodeReq,
+            cacheConfig,
+            serverRoutes: routes,
+            params,
+            monitors,
+            locals,
+            rscClientManifest,
+            rscSSRManifest,
+            rscServerManifest,
+            serverManifest,
+            loaderContext: loaderContext || new Map(),
+            onError,
+            onTiming,
+            reporter
+        };
+        if (fallbackReason) renderOptions.html = injectFallbackReasonToHtml({
+            html: renderOptions.html,
+            reason: fallbackReason,
+            framework
+        });
+        let response;
+        switch(renderMode){
+            case 'data':
+                response = await dataHandler(req, renderOptions) || await renderHandler(req, renderOptions, 'ssr', fallbackWrapper, framework);
+                break;
+            case 'rsc-tree':
+                response = await renderRscHandler(req, renderOptions);
+                break;
+            case 'rsc-action':
+                response = await serverActionHandler(req, renderOptions);
+                break;
+            case 'ssr':
+            case 'csr':
+                response = await renderHandler(req, renderOptions, renderMode, fallbackWrapper, framework);
+                break;
+            default:
+                throw new Error(`Unknown render mode: ${renderMode}`);
+        }
+        if (fallbackReason) response.headers.set(fallbackHeader, `1;reason=${fallbackReason}`);
+        return response;
+    };
+}
+async function renderHandler(request, options, mode, fallbackWrapper, framework) {
+    let response = null;
+    const { serverManifest } = options;
+    const ssrByRouteIds = options.config.server?.ssrByRouteIds;
+    const runtimeEnv = getRuntimeEnv();
+    if (serverManifest.nestedRoutesJson && ssrByRouteIds && ssrByRouteIds?.length > 0 && 'node' === runtimeEnv) {
+        const { nestedRoutesJson } = serverManifest;
+        const routes = nestedRoutesJson?.[options.routeInfo.entryName];
+        if (routes) {
+            const { matchRoutes } = __webpack_require__("@modern-js/runtime-utils/router");
+            const url = new URL(request.url);
+            const matchedRoutes = matchRoutes(routes, url.pathname, options.routeInfo.urlPath);
+            if (matchedRoutes) {
+                const lastMatch = matchedRoutes[matchedRoutes.length - 1];
+                if (!lastMatch?.route?.id || !ssrByRouteIds.includes(lastMatch.route.id)) response = await csrRender(request, options);
+            } else response = await csrRender(request, options);
+        }
+    }
+    if ('ssr' !== mode || response) response = await csrRender(request, options);
+    else try {
+        response = await ssrRender(request, options);
+    } catch (e) {
+        options.onError(e, ErrorDigest.ERENDER);
+        await fallbackWrapper('error', e);
+        response = await csrRender(request, {
+            ...options,
+            html: injectFallbackReasonToHtml({
+                html: options.html,
+                reason: 'error',
+                framework
+            })
+        });
+    }
+    const { routeInfo } = options;
+    applyExtendHeaders(response, routeInfo);
+    return response;
+    function applyExtendHeaders(r, route) {
+        Object.entries(route.responseHeaders || {}).forEach(([k, v])=>{
+            r.headers.set(k, v);
+        });
+    }
+}
+async function getRenderMode(req, fallbackHeader, isSSR, forceCSR, nodeReq, onFallback, contextForceCSR) {
+    const query = parseQuery(req);
+    if (req.headers.get('x-rsc-action')) return 'rsc-action';
+    if (req.headers.get('x-rsc-tree')) return 'rsc-tree';
+    if (!isSSR) return 'csr';
+    {
+        if (query.__loader) return 'data';
+        const fallbackHeaderValue = req.headers.get(fallbackHeader) || nodeReq?.headers[fallbackHeader];
+        if (forceCSR && (query.csr || fallbackHeaderValue || contextForceCSR)) {
+            if (query.csr) await onFallback?.('query');
+            else {
+                const reason = fallbackHeaderValue?.split(';')[1]?.split('=')[1];
+                await onFallback?.(reason ? `header,${reason}` : 'header');
+            }
+            return 'csr';
+        }
+        return 'ssr';
+    }
+}
+function injectFallbackReasonToHtml({ html, reason, framework }) {
+    const tag = `<script id="__${framework}_ssr_fallback_reason__" type="application/json">${JSON.stringify({
+        reason
+    })}</script>`;
+    return html.replace(/<\/head>/, `${tag}</head>`);
+}
+async function csrRender(request, options) {
+    const { html, rscClientManifest } = options;
+    if (!rscClientManifest || process.env.MODERN_DISABLE_INJECT_RSC_DATA) return new Response(html, {
+        status: 200,
+        headers: new Headers({
+            'content-type': 'text/html; charset=UTF-8',
+            [X_MODERNJS_RENDER]: 'client'
+        })
+    });
+    return csrRscRender(request, options);
+}
+export { createRender };

package/dist/esm-node/plugins/render/renderRscHandler.mjs

@@ -0,0 +1,41 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { createRequestHandlerConfig } from "./utils.mjs";
+const renderRscHandler = async (req, options)=>{
+    const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, monitors, onError, onTiming, staticGenerate } = options;
+    const serverBundle = serverManifest?.renderBundles?.[routeInfo.entryName || MAIN_ENTRY_NAME];
+    const loadableStats = serverManifest.loadableStats || {};
+    const routeManifest = serverManifest.routeManifest || {};
+    const config = createRequestHandlerConfig(options.config);
+    const requestHandlerOptions = {
+        resource: {
+            route: routeInfo,
+            loadableStats,
+            routeManifest,
+            entryName: routeInfo.entryName || MAIN_ENTRY_NAME
+        },
+        config,
+        params,
+        loaderContext,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter: options.reporter
+    };
+    if (!serverBundle) return new Response('Cannot find server bundle for RSC', {
+        status: 500
+    });
+    const rscPayloadHandler = await serverBundle.rscPayloadHandler;
+    if (!rscPayloadHandler) return new Response('Cannot find request handler for RSC', {
+        status: 500
+    });
+    if (!rscClientManifest) return new Response('Cannot find rsc client manifest', {
+        status: 500
+    });
+    return rscPayloadHandler(req, requestHandlerOptions);
+};
+export { renderRscHandler };

package/dist/esm-node/plugins/render/serverActionHandler.mjs

@@ -0,0 +1,18 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+const serverActionHandler = async (req, { serverManifest, routeInfo, rscClientManifest })=>{
+    const serverBundle = serverManifest?.renderBundles?.[routeInfo.entryName || MAIN_ENTRY_NAME];
+    if (!serverBundle) return new Response('Cannot find server bundle for server action', {
+        status: 500
+    });
+    const { handleAction } = serverBundle;
+    if (!handleAction) return new Response('Cannot find server action handler', {
+        status: 500
+    });
+    if (!rscClientManifest) return new Response('Cannot find rsc client manifest', {
+        status: 500
+    });
+    return handleAction(req, {
+        clientManifest: rscClientManifest
+    });
+};
+export { serverActionHandler };

package/dist/esm-node/plugins/render/ssrCache.mjs

@@ -0,0 +1,158 @@
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { X_RENDER_CACHE } from "../../constants.mjs";
+import { createTransformStream, getPathname } from "../../utils/index.mjs";
+const removeTailSlash = (s)=>s.replace(/\/+$/, '');
+const ZERO_RENDER_LEVEL = /"renderLevel":0/;
+const NO_SSR_CACHE = /<meta\s+[^>]*name=["']no-ssr-cache["'][^>]*>/i;
+async function processCache({ request, key, requestHandler, requestHandlerOptions, ttl, container, cacheStatus }) {
+    const response = await requestHandler(request, requestHandlerOptions);
+    const { onError } = requestHandlerOptions;
+    const nonCacheableStatusCodes = [
+        204,
+        305,
+        404,
+        405,
+        500,
+        501,
+        502,
+        503,
+        504
+    ];
+    if (nonCacheableStatusCodes.includes(response.status)) return response;
+    const decoder = new TextDecoder();
+    if (response.body) {
+        const stream = createTransformStream();
+        const reader = response.body.getReader();
+        const writer = stream.writable.getWriter();
+        let html = '';
+        const push = ()=>reader.read().then(({ done, value })=>{
+                if (done) {
+                    const match = ZERO_RENDER_LEVEL.test(html) || NO_SSR_CACHE.test(html);
+                    if (match) return void writer.close();
+                    const current = Date.now();
+                    const cache = {
+                        val: html,
+                        cursor: current
+                    };
+                    container.set(key, JSON.stringify(cache), {
+                        ttl
+                    }).catch(()=>{
+                        if (onError) onError(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
+                        else console.error(`[render-cache] set cache failed, key: ${key}, value: ${JSON.stringify(cache)}`);
+                    });
+                    writer.close();
+                    return;
+                }
+                const content = decoder.decode(value);
+                html += content;
+                writer.write(value);
+                push();
+            });
+        push();
+        cacheStatus && response.headers.set(X_RENDER_CACHE, cacheStatus);
+        return new Response(stream.readable, {
+            status: response.status,
+            headers: response.headers
+        });
+    }
+    return response;
+}
+const CACHE_NAMESPACE = '__ssr__cache';
+const storage = createMemoryStorage(CACHE_NAMESPACE);
+function computedKey(req, cacheControl) {
+    const pathname = getPathname(req);
+    const { customKey } = cacheControl;
+    const defaultKey = '/' === pathname ? pathname : removeTailSlash(pathname);
+    if (!customKey) return defaultKey;
+    if ('string' == typeof customKey) return customKey;
+    return customKey(defaultKey);
+}
+function shouldUseCache(request) {
+    const url = new URL(request.url);
+    const hasRSCAction = request.headers.has('x-rsc-action');
+    const hasRSCTree = request.headers.has('x-rsc-tree');
+    const hasLoaderQuery = url.searchParams.has('__loader');
+    return !(hasRSCAction || hasRSCTree || hasLoaderQuery);
+}
+function matchCacheControl(cacheOption, req) {
+    if (!cacheOption || !req) return;
+    {
+        if (isCacheControl(cacheOption)) return cacheOption;
+        if (isCacheOptionProvider(cacheOption)) return cacheOption(req);
+        const url = req.url;
+        const options = Object.entries(cacheOption);
+        for (const [key, option] of options)if ('*' === key || new RegExp(key).test(url)) if ('function' == typeof option) return option(req);
+        else return option;
+        return;
+    }
+    function isCacheOptionProvider(option) {
+        return 'function' == typeof option;
+    }
+    function isCacheControl(option) {
+        return 'object' == typeof option && null !== option && 'maxAge' in option;
+    }
+}
+async function getCacheResult(request, options) {
+    const { cacheControl, container = storage, requestHandler, requestHandlerOptions } = options;
+    const { onError } = requestHandlerOptions;
+    const key = computedKey(request, cacheControl);
+    let value;
+    try {
+        value = await container.get(key);
+    } catch (_) {
+        if (onError) onError(`[render-cache] get cache failed, key: ${key}`);
+        else console.error(`[render-cache] get cache failed, key: ${key}`);
+        value = void 0;
+    }
+    const { maxAge, staleWhileRevalidate } = cacheControl;
+    const ttl = maxAge + staleWhileRevalidate;
+    if (!value) return processCache({
+        key,
+        request,
+        requestHandler,
+        requestHandlerOptions,
+        ttl,
+        container,
+        cacheStatus: 'miss'
+    });
+    {
+        const cache = JSON.parse(value);
+        const interval = Date.now() - cache.cursor;
+        if (interval <= maxAge) {
+            const cacheStatus = 'hit';
+            return new Response(cache.val, {
+                headers: {
+                    [X_RENDER_CACHE]: cacheStatus
+                }
+            });
+        }
+        if (!(interval <= staleWhileRevalidate + maxAge)) return processCache({
+            key,
+            request,
+            requestHandler,
+            requestHandlerOptions,
+            ttl,
+            container,
+            cacheStatus: 'expired'
+        });
+        {
+            processCache({
+                key,
+                request,
+                requestHandler,
+                requestHandlerOptions,
+                ttl,
+                container
+            }).then(async (response)=>{
+                await response.text();
+            });
+            const cacheStatus = 'stale';
+            return new Response(cache.val, {
+                headers: {
+                    [X_RENDER_CACHE]: cacheStatus
+                }
+            });
+        }
+    }
+}
+export { getCacheResult, matchCacheControl, shouldUseCache };

package/dist/esm-node/plugins/render/ssrRender.mjs

@@ -0,0 +1,62 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { X_MODERNJS_RENDER } from "../../constants.mjs";
+import { getPathname, parseHeaders } from "../../utils/index.mjs";
+import { getCacheResult, matchCacheControl, shouldUseCache } from "./ssrCache.mjs";
+import { createRequestHandlerConfig } from "./utils.mjs";
+const SERVER_RUNTIME_ENTRY = 'requestHandler';
+async function ssrRender(request, { routeInfo, html, config: userConfig, staticGenerate, nodeReq, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, monitors, cacheConfig, onError, onTiming, reporter }) {
+    const { entryName } = routeInfo;
+    const loadableStats = serverManifest.loadableStats || {};
+    const routeManifest = serverManifest.routeManifest || {};
+    const headers = parseHeaders(request);
+    if (nodeReq) {
+        for(const key in nodeReq.headers)if (!headers[key]) headers[key] = nodeReq.headers[key];
+    }
+    const renderBundle = serverManifest.renderBundles?.[entryName || MAIN_ENTRY_NAME];
+    if (!renderBundle) throw new Error(`Can't find renderBundle ${entryName || MAIN_ENTRY_NAME}`);
+    const requestHandler = await renderBundle[SERVER_RUNTIME_ENTRY];
+    const config = createRequestHandlerConfig(userConfig);
+    const requestHandlerOptions = {
+        resource: {
+            route: routeInfo,
+            loadableStats,
+            routeManifest,
+            htmlTemplate: html,
+            entryName: entryName || MAIN_ENTRY_NAME
+        },
+        params,
+        loaderContext,
+        config,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter
+    };
+    const cacheControl = await matchCacheControl(cacheConfig?.strategy, nodeReq || new IncomingMessgeProxy(request));
+    let response;
+    response = cacheControl && shouldUseCache(request) ? await getCacheResult(request, {
+        cacheControl,
+        container: cacheConfig?.container,
+        requestHandler: requestHandler,
+        requestHandlerOptions
+    }) : await requestHandler(request, requestHandlerOptions);
+    response.headers.set(X_MODERNJS_RENDER, 'server');
+    response.headers.set('content-type', 'text/html; charset=UTF-8');
+    return response;
+}
+class IncomingMessgeProxy {
+    constructor(req){
+        this.headers = {};
+        req.headers.forEach((value, key)=>{
+            this.headers[key] = value;
+        });
+        this.method = req.method;
+        this.url = getPathname(req);
+    }
+}
+export { ssrRender };

package/dist/esm-node/plugins/render/utils.mjs

@@ -0,0 +1,15 @@
+function createRequestHandlerConfig(userConfig) {
+    const { output, server, security, html, source } = userConfig;
+    return {
+        ssr: server?.ssr,
+        ssrByEntries: server?.ssrByEntries,
+        nonce: security?.nonce,
+        inlineScripts: output?.inlineScripts,
+        inlineStyles: output?.inlineStyles,
+        crossorigin: html?.crossorigin,
+        scriptLoading: html?.scriptLoading,
+        useJsonScript: server?.useJsonScript,
+        enableAsyncEntry: source?.enableAsyncEntry
+    };
+}
+export { createRequestHandlerConfig };

package/dist/esm-node/plugins/route.mjs

@@ -0,0 +1,34 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { sortRoutes } from "../utils/index.mjs";
+function injectRoute(route) {
+    return async (c, next)=>{
+        if (route && !c.get('route')) c.set('route', route);
+        await next();
+    };
+}
+function getPageRoutes(routes) {
+    return routes.filter((route)=>route.entryName).sort(sortRoutes);
+}
+const injectRoutePlugin = ()=>({
+        name: '@modern-js/plugin-inject-route',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, routes } = api.getServerContext();
+                if (!routes) return;
+                const pageRoutes = getPageRoutes(routes);
+                for (const route of pageRoutes){
+                    const { urlPath: originUrlPath, entryName = MAIN_ENTRY_NAME } = route;
+                    const urlPath = originUrlPath.endsWith('/') ? `${originUrlPath}*` : `${originUrlPath}/*`;
+                    middlewares.push({
+                        name: 'inject-route-info',
+                        path: urlPath,
+                        handler: injectRoute({
+                            entryName,
+                            urlPath: originUrlPath
+                        })
+                    });
+                }
+            });
+        }
+    });
+export { injectRoutePlugin };