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

package/dist/esm-node/hono.mjs

@@ -0,0 +1,3 @@
+import { deleteCookie, getCookie, setCookie } from "hono/cookie";
+import { languageDetector } from "hono/language";
+export { deleteCookie, getCookie, languageDetector, setCookie };

package/dist/esm-node/index.mjs

@@ -0,0 +1,13 @@
+import { ErrorDigest, createErrorHtml, onError } from "./utils/index.mjs";
+import { getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, resolvePublicDirPaths } from "./utils/publicDir.mjs";
+import { AGGRED_DIR } from "./constants.mjs";
+import { createServerBase } from "./serverBase.mjs";
+import { useHonoContext } from "./context.mjs";
+import { Hono } from "hono";
+import { getLoaderCtx } from "./helper.mjs";
+export * from "./plugins/index.mjs";
+export * from "./types/plugins/index.mjs";
+export * from "./types/render.mjs";
+export * from "./types/config/index.mjs";
+export * from "./types/requestHandler.mjs";
+export { AGGRED_DIR, ErrorDigest, Hono, createErrorHtml, createServerBase, getLoaderCtx, getPublicDirConfig, getPublicDirPatterns, getPublicDirRoutePrefixes, normalizePublicDir, normalizePublicDirPath, onError, resolvePublicDirPaths, useHonoContext };

package/dist/esm-node/plugins/compat/hooks.mjs

@@ -0,0 +1,40 @@
+function getHookRunners(context) {
+    const { hooks } = context;
+    return {
+        config: (params)=>hooks.modifyConfig.call(params),
+        prepare: ()=>hooks.onPrepare.call(),
+        reset: (params)=>hooks.onReset.call(params),
+        fallback: (input)=>hooks.fallback.call(input),
+        prepareWebServer: (input)=>hooks.prepareWebServer.call(input),
+        prepareApiServer: (input)=>hooks.prepareApiServer.call(input),
+        afterMatch: (ctx)=>hooks.afterMatch.call(ctx),
+        afterRender: (ctx)=>hooks.afterRender.call(ctx),
+        afterStreamingRender: (ctx)=>hooks.afterStreamingRender.call(ctx)
+    };
+}
+function transformHookRunner(hookRunnerName) {
+    switch(hookRunnerName){
+        case 'config':
+            return 'modifyConfig';
+        case 'prepare':
+            return 'onPrepare';
+        case 'reset':
+            return 'onReset';
+        default:
+            return hookRunnerName;
+    }
+}
+function handleSetupResult(setupResult, api) {
+    if (!setupResult) return;
+    Object.keys(setupResult).forEach((key)=>{
+        const fn = setupResult[key];
+        if ('function' == typeof fn) {
+            const newAPI = transformHookRunner(key);
+            if (api[newAPI]) api[newAPI]((...params)=>{
+                const res = fn(...params);
+                return res;
+            });
+        }
+    });
+}
+export { getHookRunners, handleSetupResult, transformHookRunner };

package/dist/esm-node/plugins/compat/index.mjs

@@ -0,0 +1,27 @@
+import { createAsyncHook, createAsyncPipelineHook } from "@modern-js/plugin";
+import { getHookRunners, handleSetupResult } from "./hooks.mjs";
+const compatPlugin = ()=>({
+        name: '@modern-js/server-compat',
+        registryHooks: {
+            fallback: createAsyncHook(),
+            prepareWebServer: createAsyncPipelineHook(),
+            prepareApiServer: createAsyncPipelineHook(),
+            afterMatch: createAsyncPipelineHook(),
+            afterRender: createAsyncPipelineHook(),
+            afterStreamingRender: createAsyncPipelineHook()
+        },
+        _registryApi: (getServerContext, updateServerContext)=>{
+            const getInternalContext = ()=>getServerContext()._internalContext;
+            return {
+                useConfigContext: ()=>getInternalContext().config,
+                useAppContext: ()=>{
+                    const { _internalContext, ...serverContext } = getServerContext();
+                    return serverContext;
+                },
+                setAppContext: (context)=>updateServerContext(context),
+                useHookRunners: ()=>getHookRunners(getInternalContext())
+            };
+        },
+        setup: ()=>{}
+    });
+export { compatPlugin, handleSetupResult };

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

@@ -0,0 +1,25 @@
+import { compatPlugin } from "./compat/index.mjs";
+import { logPlugin } from "./log.mjs";
+import { initMonitorsPlugin, injectServerTiming, injectloggerPlugin } from "./monitors.mjs";
+import { processedByPlugin } from "./processedBy.mjs";
+import { injectRenderHandlerPlugin } from "./render/index.mjs";
+import { injectRoutePlugin } from "./route.mjs";
+function createSilenceLogger() {
+    return new Proxy({}, {
+        get: ()=>()=>{}
+    });
+}
+function createDefaultPlugins(options = {}) {
+    const plugins = [
+        compatPlugin(),
+        logPlugin(),
+        initMonitorsPlugin(),
+        injectRenderHandlerPlugin(options),
+        injectloggerPlugin(options.logger ? options.logger : createSilenceLogger()),
+        injectServerTiming(),
+        processedByPlugin(),
+        injectRoutePlugin()
+    ];
+    return plugins;
+}
+export { createDefaultPlugins };

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

@@ -0,0 +1,14 @@
+const faviconPlugin = ()=>({
+        name: '@modern-js/plugin-favicon',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'favicon-fallback',
+                    path: '/favicon.ico',
+                    handler: async (c, _next)=>c.body(null, 204)
+                });
+            });
+        }
+    });
+export { faviconPlugin };

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

@@ -0,0 +1,9 @@
+import { getRenderHandler, injectRenderHandlerPlugin, renderPlugin } from "./render/index.mjs";
+import { faviconPlugin } from "./favicon.mjs";
+import { injectServerTiming, injectloggerPlugin } from "./monitors.mjs";
+import { processedByPlugin } from "./processedBy.mjs";
+import { logPlugin } from "./log.mjs";
+import { createDefaultPlugins } from "./default.mjs";
+import { compatPlugin, handleSetupResult } from "./compat/index.mjs";
+import { injectConfigMiddlewarePlugin } from "./middlewares.mjs";
+export { compatPlugin, createDefaultPlugins, faviconPlugin, getRenderHandler, handleSetupResult, injectConfigMiddlewarePlugin, injectRenderHandlerPlugin, injectServerTiming, injectloggerPlugin, logPlugin, processedByPlugin, renderPlugin };

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

@@ -0,0 +1,58 @@
+import { getPathname } from "../utils/index.mjs";
+const humanize = (times)=>{
+    const [delimiter, separator] = [
+        ',',
+        '.'
+    ];
+    const orderTimes = times.map((v)=>v.replace(/(\d)(?=(\d\d\d)+(?!\d))/g, `$1${delimiter}`));
+    return orderTimes.join(separator);
+};
+const time = (start)=>{
+    const delta = Date.now() - start;
+    return humanize([
+        delta < 1000 ? `${delta}ms` : `${Math.round(delta / 1000)}s`
+    ]);
+};
+const colorStatus = (status)=>{
+    const out = {
+        7: `\x1b[35m${status}\x1b[0m`,
+        5: `\x1b[31m${status}\x1b[0m`,
+        4: `\x1b[33m${status}\x1b[0m`,
+        3: `\x1b[36m${status}\x1b[0m`,
+        2: `\x1b[32m${status}\x1b[0m`,
+        1: `\x1b[32m${status}\x1b[0m`,
+        0: `\x1b[33m${status}\x1b[0m`
+    };
+    const calculateStatus = Math.floor(status / 100);
+    return out[calculateStatus];
+};
+function log(fn, prefix, method, path, status = 0, elapsed) {
+    const out = "<--" === prefix ? `  ${prefix} ${method} ${path}` : `  ${prefix} ${method} ${path} ${colorStatus(status)} ${elapsed}`;
+    fn(out);
+}
+function logHandler() {
+    return async function(c, next) {
+        const { method } = c.req;
+        const monitors = c.get('monitors');
+        if (!monitors) return void await next();
+        const path = getPathname(c.req.raw);
+        const logFn = monitors.debug;
+        log(logFn, "<--", method, path);
+        const start = Date.now();
+        await next();
+        log(logFn, "-->", method, path, c?.env?.node?.res?.statusCode ?? c.res.status, time(start));
+    };
+}
+const logPlugin = ()=>({
+        name: '@modern-js/plugin-log',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'print_log',
+                    handler: logHandler()
+                });
+            });
+        }
+    });
+export { logPlugin };

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

@@ -0,0 +1,15 @@
+const injectConfigMiddlewarePlugin = (configMiddlewares = [], configRenderMiddlewares = [])=>({
+        name: '@modern-js/plugin-inject-config-middleware',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, renderMiddlewares } = api.getServerContext();
+                configMiddlewares.forEach((m)=>{
+                    middlewares.push(m);
+                });
+                configRenderMiddlewares.forEach((m)=>{
+                    renderMiddlewares.push(m);
+                });
+            });
+        }
+    });
+export { injectConfigMiddlewarePlugin };

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

@@ -0,0 +1,149 @@
+import { time } from "@modern-js/runtime-utils/time";
+import { SERVER_TIMING, ServerTimings } from "../constants.mjs";
+function createMonitors() {
+    const coreMonitors = [];
+    const log = (level, message, args)=>{
+        const event = {
+            type: 'log',
+            payload: {
+                level,
+                message,
+                args
+            }
+        };
+        coreMonitors.forEach((monitor)=>monitor(event));
+    };
+    const mointors = {
+        push (monitor) {
+            coreMonitors.push(monitor);
+        },
+        error (message, ...args) {
+            log('error', message, args);
+        },
+        warn (message, ...args) {
+            log('warn', message, args);
+        },
+        debug (message, ...args) {
+            log('debug', message, args);
+        },
+        info (message, ...args) {
+            log('info', message, args);
+        },
+        trace (message, ...args) {
+            log('trace', message, args);
+        },
+        timing (name, dur, desc, tags, ...args) {
+            const event = {
+                type: 'timing',
+                payload: {
+                    name,
+                    dur,
+                    desc,
+                    tags,
+                    args
+                }
+            };
+            coreMonitors.forEach((monitor)=>monitor(event));
+        },
+        counter (name, tags, ...args) {
+            const event = {
+                type: 'counter',
+                payload: {
+                    name,
+                    args,
+                    tags
+                }
+            };
+            coreMonitors.forEach((monitor)=>monitor(event));
+        }
+    };
+    return mointors;
+}
+const initMonitorsPlugin = ()=>({
+        name: '@modern-js/init-mointor',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'init-monitor',
+                    handler: async (c, next)=>{
+                        if (!c.get('monitors')) {
+                            const monitors = createMonitors();
+                            c.set('monitors', monitors);
+                        }
+                        return next();
+                    },
+                    order: 'pre'
+                });
+            });
+        }
+    });
+const injectloggerPlugin = (inputLogger)=>({
+        name: '@modern-js/inject-logger',
+        setup (api) {
+            const logger = inputLogger;
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'inject-logger',
+                    handler: async (c, next)=>{
+                        const pathname = c.req.path;
+                        const loggerMonitor = (event)=>{
+                            if ('log' === event.type) {
+                                const { level, message, args } = event.payload;
+                                if ('trace' === level) logger.info(message, ...args || []);
+                                else logger[level](message, ...args || []);
+                            }
+                            if ('timing' === event.type) {
+                                const { name, dur, desc } = event.payload;
+                                if (desc) logger.debug(`%s Debug - ${name}, cost: %s, req.url = %s `, desc, dur, pathname);
+                                else logger.debug(`Debug - ${name}, cost: %s, req.url = %s`, dur, pathname);
+                            }
+                        };
+                        const monitors = c.get('monitors');
+                        monitors?.push(loggerMonitor);
+                        return next();
+                    }
+                });
+            });
+        }
+    });
+const injectServerTiming = ()=>({
+        name: '@modern-js/inject-server-timing',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares, metaName } = api.getServerContext();
+                middlewares.push({
+                    name: 'inject-server-timing',
+                    handler: async (c, next)=>{
+                        const serverTimings = [];
+                        const timingMonitor = (event)=>{
+                            if ('timing' === event.type) serverTimings.push(event.payload);
+                        };
+                        const monitors = c.get('monitors');
+                        monitors?.push(timingMonitor);
+                        await next();
+                        serverTimings.forEach((serverTiming)=>{
+                            const { name, desc, dur } = serverTiming;
+                            const _name = `bd-${metaName}-${name}`;
+                            const value = `${_name};${desc ? `decs="${desc}";` : ''} dur=${dur}`;
+                            c.header(SERVER_TIMING, value, {
+                                append: true
+                            });
+                        });
+                    }
+                });
+            });
+        }
+    });
+function requestLatencyMiddleware() {
+    return async (c, next)=>{
+        const monitors = c.get('monitors');
+        if (!monitors) return void await next();
+        const getCost = time();
+        await next();
+        const cost = getCost();
+        monitors.timing(ServerTimings.SERVER_HANDLE_REQUEST, cost);
+    };
+}
+export { initMonitorsPlugin, injectServerTiming, injectloggerPlugin, requestLatencyMiddleware };

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

@@ -0,0 +1,16 @@
+const processedByPlugin = ()=>({
+        name: '@modern-js/plugin-processed',
+        setup (api) {
+            api.onPrepare(()=>{
+                const { middlewares } = api.getServerContext();
+                middlewares.push({
+                    name: 'processed-by',
+                    handler: async (c, next)=>{
+                        await next();
+                        c.header('X-Processed-By', 'Modern.js');
+                    }
+                });
+            });
+        }
+    });
+export { processedByPlugin };

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

@@ -0,0 +1,43 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+import { createRequestHandlerConfig } from "./utils.mjs";
+const csrRscRender = async (req, options)=>{
+    const { routeInfo, serverManifest, rscSSRManifest, rscClientManifest, rscServerManifest, locals, params, loaderContext, reporter, monitors, onError, onTiming, staticGenerate, html } = 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,
+        html,
+        rscSSRManifest,
+        rscClientManifest,
+        rscServerManifest,
+        locals,
+        staticGenerate,
+        monitors,
+        onError,
+        onTiming,
+        reporter: reporter
+    };
+    if (!serverBundle) return new Response('Cannot find server bundle for RSC', {
+        status: 500
+    });
+    const renderRscStreamHandler = await serverBundle.renderRscStreamHandler;
+    if (!renderRscStreamHandler) return new Response('Cannot find render handler for RSC', {
+        status: 500
+    });
+    if (!rscClientManifest) return new Response('Cannot find rsc client manifest', {
+        status: 500
+    });
+    const response = await renderRscStreamHandler(req, requestHandlerOptions);
+    return response;
+};
+export { csrRscRender };

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

@@ -0,0 +1,19 @@
+import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
+const dataHandler = async (request, { routeInfo, serverRoutes, monitors, onError, onTiming, serverManifest, loaderContext })=>{
+    const serverLoaderModule = serverManifest?.loaderBundles?.[routeInfo.entryName || MAIN_ENTRY_NAME];
+    if (!serverLoaderModule) return;
+    const { routes, handleRequest } = serverLoaderModule;
+    const response = await handleRequest({
+        request,
+        serverRoutes,
+        context: {
+            monitors,
+            loaderContext
+        },
+        onTiming,
+        onError,
+        routes
+    });
+    return response;
+};
+export { dataHandler };

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

@@ -0,0 +1,84 @@
+import { getLoaderCtx } from "../../helper.mjs";
+import { sortRoutes } from "../../utils/index.mjs";
+import { requestLatencyMiddleware } from "../monitors.mjs";
+export * from "./inject.mjs";
+const DYNAMIC_ROUTE_REG = /\/:./;
+function escapeRegexSpecialChars(path) {
+    return path.replace(/[()[\]{}*+?.^$|\\]/g, '\\$&');
+}
+const renderPlugin = ()=>({
+        name: '@modern-js/plugin-render',
+        setup (api) {
+            api.onPrepare(async ()=>{
+                const { middlewares, routes, render, renderMiddlewares } = api.getServerContext();
+                if (!routes) return;
+                const pageRoutes = getPageRoutes(routes);
+                middlewares.push({
+                    name: 'page-latency',
+                    handler: requestLatencyMiddleware()
+                });
+                for (const route of pageRoutes){
+                    const { urlPath: originUrlPath } = route;
+                    const isDynamic = DYNAMIC_ROUTE_REG.test(originUrlPath);
+                    const escapedPath = isDynamic ? originUrlPath : escapeRegexSpecialChars(originUrlPath);
+                    const urlPath = escapedPath.endsWith('/') ? `${escapedPath}*` : `${escapedPath}/*`;
+                    renderMiddlewares?.forEach((m)=>{
+                        middlewares.push({
+                            name: m.name,
+                            path: urlPath,
+                            handler: m.handler
+                        });
+                    });
+                    render && middlewares.push({
+                        name: "render",
+                        path: urlPath,
+                        handler: createRenderHandler(render)
+                    });
+                }
+            });
+        }
+    });
+function getPageRoutes(routes) {
+    return routes.filter((route)=>!route.isApi).sort(sortRoutes);
+}
+function createRenderHandler(render) {
+    return async (c, _)=>{
+        const reporter = c.get('reporter');
+        const monitors = c.get('monitors');
+        const templates = c.get('templates') || {};
+        const serverManifest = c.get('serverManifest') || {};
+        const rscServerManifest = c.get('rscServerManifest');
+        const rscClientManifest = c.get('rscClientManifest');
+        const rscSSRManifest = c.get('rscSSRManifest');
+        const locals = c.get('locals');
+        c.get('metrics');
+        const matchPathname = c.get('matchPathname');
+        const matchEntryName = c.get('matchEntryName');
+        const loaderContext = getLoaderCtx(c);
+        const contextForceCSR = c.get('forceCSR');
+        const request = c.req.raw;
+        const nodeReq = c.env.node?.req;
+        const res = await render(request, {
+            nodeReq,
+            monitors,
+            templates,
+            serverManifest,
+            rscServerManifest,
+            rscClientManifest,
+            rscSSRManifest,
+            loaderContext,
+            locals,
+            matchPathname,
+            matchEntryName,
+            contextForceCSR,
+            reporter
+        });
+        const { body, status, headers } = res;
+        const headersData = {};
+        headers.forEach((v, k)=>{
+            headersData[k] = v;
+        });
+        return c.body(body, status, headersData);
+    };
+}
+export { renderPlugin };

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

@@ -0,0 +1,55 @@
+import { createRender } from "./render.mjs";
+const injectRenderHandlerPlugin = ({ staticGenerate, cacheConfig })=>({
+        name: '@modern-js/plugin-inject-render',
+        setup (api) {
+            api.onPrepare(async ()=>{
+                const { distDirectory: pwd, routes, metaName } = api.getServerContext();
+                const config = api.getServerConfig();
+                const hooks = api.getHooks();
+                if (!routes) return;
+                const onFallback = async (reason, error)=>{
+                    await hooks.fallback.call({
+                        reason,
+                        error
+                    });
+                };
+                const getRenderHandlerOptions = {
+                    pwd: pwd,
+                    routes,
+                    config,
+                    metaName,
+                    cacheConfig: cacheConfig,
+                    staticGenerate,
+                    onFallback
+                };
+                const render = await getRenderHandler(getRenderHandlerOptions);
+                api.updateServerContext({
+                    render,
+                    getRenderOptions: getRenderHandlerOptions
+                });
+            });
+        }
+    });
+async function getRenderHandler({ pwd, routes, config, cacheConfig, metaName, staticGenerate, onFallback }) {
+    const ssrConfig = config.server?.ssr;
+    const ssrByEntries = config.server?.ssrByEntries;
+    const forceCSR = 'object' == typeof ssrConfig ? ssrConfig.forceCSR : false;
+    const forceCSRMap = new Map();
+    if (ssrByEntries) Object.entries(ssrByEntries).forEach(([entryName, ssrConfig])=>{
+        forceCSRMap.set(entryName, 'object' == typeof ssrConfig ? ssrConfig.forceCSR ?? false : false);
+    });
+    const render = createRender({
+        routes,
+        pwd,
+        config,
+        staticGenerate,
+        cacheConfig,
+        forceCSR,
+        forceCSRMap,
+        nonce: config.security?.nonce,
+        metaName: metaName || 'modern-js',
+        onFallback
+    });
+    return render;
+}
+export { getRenderHandler, injectRenderHandlerPlugin };