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

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

@@ -0,0 +1,159 @@
+import "node:module";
+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,63 @@
+import "node:module";
+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,16 @@
+import "node:module";
+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,35 @@
+import "node:module";
+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 };