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

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

@@ -0,0 +1,41 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { createRequestHandlerConfig } from "./utils";
+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/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/plugins/render/ssrCache.mjs

@@ -0,0 +1,158 @@
+import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
+import { X_RENDER_CACHE } from "../../constants";
+import { createTransformStream, getPathname } from "../../utils";
+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/plugins/render/ssrRender.mjs

@@ -0,0 +1,62 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { X_MODERNJS_RENDER } from "../../constants";
+import { getPathname, parseHeaders } from "../../utils";
+import { getCacheResult, matchCacheControl, shouldUseCache } from "./ssrCache";
+import { createRequestHandlerConfig } from "./utils";
+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/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/plugins/route.mjs

@@ -0,0 +1,34 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { sortRoutes } from "../utils";
+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 };

package/dist/esm/serverBase.mjs

@@ -0,0 +1,136 @@
+import { server as server_server } from "@modern-js/plugin/server";
+import { Hono } from "hono";
+import { run } from "./context";
+import { handleSetupResult } from "./plugins/compat/hooks";
+import { loadConfig } from "./utils";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var _applyMiddlewares = /*#__PURE__*/ new WeakSet();
+class ServerBase {
+    async init() {
+        const { serverConfig, config: cliConfig } = this.options;
+        const mergedConfig = loadConfig({
+            cliConfig,
+            serverConfig: serverConfig || {}
+        });
+        const { serverContext } = await server_server.run({
+            plugins: this.plugins,
+            options: this.options,
+            config: mergedConfig,
+            handleSetupResult: handleSetupResult
+        });
+        serverContext.serverBase = this;
+        this.serverContext = serverContext;
+        await serverContext.hooks.onPrepare.call();
+        _class_private_method_get(this, _applyMiddlewares, applyMiddlewares).call(this);
+        return this;
+    }
+    addPlugins(plugins) {
+        this.plugins.push(...plugins);
+    }
+    get hooks() {
+        return this.serverContext.hooks;
+    }
+    get all() {
+        return this.app.all.bind(this.app);
+    }
+    get use() {
+        return this.app.use.bind(this.app);
+    }
+    get get() {
+        return this.app.get.bind(this.app);
+    }
+    get post() {
+        return this.app.post.bind(this.app);
+    }
+    get put() {
+        return this.app.put.bind(this.app);
+    }
+    get delete() {
+        return this.app.delete.bind(this.app);
+    }
+    get patch() {
+        return this.app.patch.bind(this.app);
+    }
+    get handle() {
+        return this.app.fetch.bind(this.app);
+    }
+    get request() {
+        return this.app.request.bind(this.app);
+    }
+    get notFound() {
+        return this.app.notFound.bind(this.app);
+    }
+    get onError() {
+        return this.app.onError.bind(this.app);
+    }
+    constructor(options){
+        _class_private_method_init(this, _applyMiddlewares);
+        this.plugins = [];
+        this.serverContext = null;
+        this.options = options;
+        this.app = new Hono();
+        this.app.use('*', run);
+    }
+}
+function applyMiddlewares() {
+    const { middlewares } = this.serverContext;
+    const preMiddlewares = [];
+    const defaultMiddlewares = [];
+    const postMiddlewares = [];
+    for (const middleware of middlewares)switch(middleware.order){
+        case 'pre':
+            preMiddlewares.push(middleware);
+            break;
+        case 'post':
+            postMiddlewares.push(middleware);
+            break;
+        default:
+            defaultMiddlewares.push(middleware);
+    }
+    const finalMiddlewares = [];
+    const insertMiddleware = (middleware)=>{
+        if (middleware.before) {
+            const targetIndex = finalMiddlewares.findIndex((item)=>{
+                if (middleware.before?.includes(item.name)) return true;
+                return false;
+            });
+            if (-1 !== targetIndex) finalMiddlewares.splice(targetIndex, 0, middleware);
+            else finalMiddlewares.push(middleware);
+        } else finalMiddlewares.push(middleware);
+    };
+    preMiddlewares.forEach(insertMiddleware);
+    defaultMiddlewares.forEach(insertMiddleware);
+    postMiddlewares.forEach(insertMiddleware);
+    for (const middleware of finalMiddlewares){
+        const { path = '*', method = 'all', handler } = middleware;
+        const handlers = handler2Handlers(handler);
+        if (0 === handlers.length) continue;
+        const firstHandler = handlers[0];
+        const restHandlers = handlers.slice(1);
+        const m = method;
+        const register = this.app[m];
+        register.call(this.app, path, firstHandler, ...restHandlers);
+    }
+    function handler2Handlers(handler) {
+        if (Array.isArray(handler)) return handler;
+        return [
+            handler
+        ];
+    }
+}
+function createServerBase(options) {
+    if (null == options) throw new Error('can not start server without options');
+    const server = new ServerBase(options);
+    return server;
+}
+export { ServerBase, createServerBase };

package/dist/esm/types/plugins/index.mjs

@@ -0,0 +1 @@
+export * from "./plugin";

package/dist/esm/utils/entry.mjs

@@ -0,0 +1,3 @@
+const sortRoutes = (route1, route2)=>route2.urlPath.length - route1.urlPath.length;
+const uniqueKeyByRoute = (route)=>`${route.entryName}-${route.urlPath}`;
+export { sortRoutes, uniqueKeyByRoute };

package/dist/esm/utils/env.mjs

@@ -0,0 +1,14 @@
+const getRuntimeEnv = ()=>{
+    if (globalThis?.process?.release?.name === 'node') return 'node';
+    return 'other';
+};
+const checkIsProd = ()=>{
+    const env = getRuntimeEnv();
+    switch(env){
+        case 'node':
+            return 'production' === process.env.NODE_ENV;
+        default:
+            return false;
+    }
+};
+export { checkIsProd, getRuntimeEnv };

package/dist/esm/utils/error.mjs

@@ -0,0 +1,53 @@
+import { parseHeaders } from "./request";
+const ERROR_PAGE_TEXT = {
+    404: 'This page could not be found.',
+    500: 'Internal Server Error.'
+};
+const createErrorHtml = (status)=>{
+    const text = ERROR_PAGE_TEXT[status] || '';
+    const title = `${status}: ${text}`;
+    return `<!DOCTYPE html>
+  <html lang="en">
+  <head>
+    <meta charset="utf-8">
+    <meta name="viewport" content="width=device-width">
+    <title>${title}</title>
+    <style>
+      html,body {
+        margin: 0;
+      }
+
+      .page-container {
+        color: #000;
+        background: #fff;
+        height: 100vh;
+        text-align: center;
+        display: flex;
+        flex-direction: column;
+        align-items: center;
+        justify-content: center;
+      }
+    </style>
+  </head>
+  <body>
+    <div class="page-container">
+    <h1>${status}</h1>
+    <div>${text}</div>
+  </body>
+  </html>
+  `;
+};
+var error_ErrorDigest = /*#__PURE__*/ function(ErrorDigest) {
+    ErrorDigest["ENOTF"] = "Page could not be found";
+    ErrorDigest["EINTER"] = "Internal server error";
+    ErrorDigest["ERENDER"] = "SSR render fallback";
+    return ErrorDigest;
+}({});
+function onError(digest, error, monitors, req) {
+    const headerData = req && parseHeaders(req);
+    headerData && delete headerData.cookie;
+    if (monitors) monitors.error(req ? `Server Error - ${digest}, error = %s, req.url = %s, req.headers = %o` : `Server Error - ${digest}, error = %s`, error instanceof Error ? error.stack || error.message : error, req?.url, headerData);
+    else if (req) console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error}, req.url = ${req.url}, req.headers = ${JSON.stringify(headerData)}`);
+    else console.error(`Server Error - ${digest}, error = ${error instanceof Error ? error.stack || error.message : error} `);
+}
+export { error_ErrorDigest as ErrorDigest, createErrorHtml, onError };

package/dist/{esm-node/utils/index.js → esm/utils/index.mjs}

@@ -6,3 +6,4 @@ export * from "./warmup";
 export * from "./entry";
 export * from "./request";
 export * from "./serverConfig";
+export * from "./publicDir";

package/dist/esm/utils/middlewareCollector.mjs

@@ -0,0 +1,26 @@
+const mergeExtension = (users)=>{
+    const output = [];
+    return {
+        middleware: output.concat(users)
+    };
+};
+const createMiddlewareCollecter = ()=>{
+    const webMiddlewares = [];
+    const apiMiddlewares = [];
+    const addWebMiddleware = (input)=>{
+        webMiddlewares.push(input);
+    };
+    const addAPIMiddleware = (input)=>{
+        apiMiddlewares.push(input);
+    };
+    const getMiddlewares = ()=>({
+            web: webMiddlewares,
+            api: apiMiddlewares
+        });
+    return {
+        getMiddlewares,
+        addWebMiddleware,
+        addAPIMiddleware
+    };
+};
+export { createMiddlewareCollecter, mergeExtension };

package/dist/esm/utils/publicDir.mjs

@@ -0,0 +1,33 @@
+import path from "path";
+function normalizePublicDir(publicDir) {
+    if (!publicDir) return [];
+    return Array.isArray(publicDir) ? publicDir : [
+        publicDir
+    ];
+}
+function normalizePublicDirPath(dir) {
+    return dir.replace(/^\.\//, '').replace(/\/$/, '');
+}
+function getPublicDirRoutePrefixes(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `/${normalized}`;
+    });
+}
+function getPublicDirPatterns(publicDir) {
+    const dirs = normalizePublicDir(publicDir);
+    return dirs.map((dir)=>{
+        const normalized = normalizePublicDirPath(dir);
+        return `${normalized}/`;
+    });
+}
+function resolvePublicDirPaths(publicDir, appDirectory) {
+    const dirs = normalizePublicDir(publicDir);
+    if (!appDirectory) return dirs;
+    return dirs.map((dir)=>path.resolve(appDirectory, dir));
+}
+function getPublicDirConfig(serverConfig) {
+    return serverConfig?.publicDir;
+}
+export { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths };

package/dist/esm/utils/request.mjs

@@ -0,0 +1,40 @@
+function parseQuery(req) {
+    const query = {};
+    const { url } = req;
+    const q = url.split('?')[1];
+    if (q) {
+        const search = new URLSearchParams(q);
+        search.forEach((v, k)=>{
+            query[k] = v;
+        });
+    }
+    return query;
+}
+function parseHeaders(request) {
+    const headersData = {};
+    request.headers.forEach((value, key)=>{
+        headersData[key] = value;
+    });
+    return headersData;
+}
+function getPathname(request) {
+    const match = request.url.match(/^https?:\/\/[^/]+(\/[^?]*)/);
+    return match ? match[1] : '/';
+}
+function getHost(request) {
+    const { headers } = request;
+    let host = headers.get('X-Forwarded-Host');
+    if (!host) host = headers.get('Host');
+    host = host?.split(/\s*,\s*/, 1)[0] || 'undefined';
+    return host;
+}
+function parseCookie(req) {
+    const _cookie = req.headers.get('Cookie');
+    const cookie = {};
+    _cookie?.trim().split(';').forEach((item)=>{
+        const [k, v] = item.trim().split('=');
+        if (k) cookie[k] = v;
+    });
+    return cookie;
+}
+export { getHost, getPathname, parseCookie, parseHeaders, parseQuery };

package/dist/esm/utils/serverConfig.mjs

@@ -0,0 +1,9 @@
+import { merge } from "ts-deepmerge";
+const loadConfig = ({ cliConfig, serverConfig })=>{
+    const config = merge({
+        ...cliConfig,
+        plugins: []
+    }, serverConfig);
+    return config;
+};
+export { loadConfig };