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

package/dist/esm/plugins/contractGateSnapshotStore.mjs

@@ -0,0 +1,180 @@
+import { fs } from "@modern-js/utils";
+import { promises } from "fs";
+import path from "path";
+const CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION = 1;
+const DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH = '.modern/contract-gates.json';
+const DEFAULT_HTTP_STORE_TIMEOUT_MS = 5000;
+const BUILTIN_HTTP_STATE_STORE_MODULES = new Set([
+    'http',
+    '@modern-js/server-core/http',
+    '@modern-js/server-core/contract-gate-http-store'
+]);
+const isRecord = (value)=>'object' == typeof value && null !== value && !Array.isArray(value);
+const normalizeSnapshot = (snapshot)=>{
+    if (!isRecord(snapshot)) return;
+    const schemaVersion = 'number' == typeof snapshot.schemaVersion ? snapshot.schemaVersion : CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION;
+    const updatedAt = 'number' == typeof snapshot.updatedAt ? snapshot.updatedAt : Date.now();
+    const gates = isRecord(snapshot.gates) ? snapshot.gates : {};
+    return {
+        schemaVersion,
+        updatedAt,
+        gates
+    };
+};
+const normalizeHttpStoreOptions = (options)=>{
+    const endpoint = 'string' == typeof options?.endpoint ? options.endpoint.trim() : '';
+    if (!endpoint) throw new Error('[telemetry.canary.autopilot] HTTP stateStore requires options.endpoint');
+    const readMethod = 'string' == typeof options?.readMethod && options.readMethod.trim() ? options.readMethod.trim().toUpperCase() : 'GET';
+    const writeMethod = 'string' == typeof options?.writeMethod && options.writeMethod.trim() ? options.writeMethod.trim().toUpperCase() : 'PUT';
+    const timeoutMsRaw = Number(options?.timeoutMs);
+    const timeoutMs = Number.isFinite(timeoutMsRaw) && timeoutMsRaw > 0 ? Math.floor(timeoutMsRaw) : DEFAULT_HTTP_STORE_TIMEOUT_MS;
+    const headersRaw = options?.headers;
+    const headers = {};
+    if (headersRaw && 'object' == typeof headersRaw && !Array.isArray(headersRaw)) Object.entries(headersRaw).forEach(([key, value])=>{
+        if ('string' == typeof key && key.trim().length > 0 && null != value) headers[key] = String(value);
+    });
+    return {
+        endpoint,
+        readMethod,
+        writeMethod,
+        headers,
+        timeoutMs
+    };
+};
+const withTimeoutAbort = (timeoutMs)=>{
+    const controller = new AbortController();
+    const timer = setTimeout(()=>controller.abort(), timeoutMs);
+    return {
+        signal: controller.signal,
+        clear: ()=>clearTimeout(timer)
+    };
+};
+const createHttpContractGateSnapshotStore = (options)=>{
+    const normalized = normalizeHttpStoreOptions(options);
+    const endpoint = normalized.endpoint;
+    return {
+        name: `http:${endpoint}`,
+        async readSnapshot () {
+            const { signal, clear } = withTimeoutAbort(normalized.timeoutMs || 5000);
+            try {
+                const response = await fetch(endpoint, {
+                    method: normalized.readMethod || 'GET',
+                    headers: {
+                        accept: 'application/json',
+                        ...normalized.headers || {}
+                    },
+                    signal
+                });
+                if (404 === response.status) return;
+                if (!response.ok) throw new Error(`HTTP stateStore read failed with status ${String(response.status)}`);
+                const payload = await response.json();
+                return normalizeSnapshot(payload);
+            } finally{
+                clear();
+            }
+        },
+        async writeSnapshot (snapshot) {
+            const body = JSON.stringify(normalizeSnapshot(snapshot) || {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: Date.now(),
+                gates: {}
+            });
+            const { signal, clear } = withTimeoutAbort(normalized.timeoutMs || 5000);
+            try {
+                const response = await fetch(endpoint, {
+                    method: normalized.writeMethod || 'PUT',
+                    headers: {
+                        'content-type': 'application/json',
+                        ...normalized.headers || {}
+                    },
+                    body,
+                    signal
+                });
+                if (!response.ok) throw new Error(`HTTP stateStore write failed with status ${String(response.status)}`);
+            } finally{
+                clear();
+            }
+        }
+    };
+};
+const tryResolveBuiltinSnapshotStore = (input)=>{
+    const moduleName = input.stateStore.module.trim();
+    if (!BUILTIN_HTTP_STATE_STORE_MODULES.has(moduleName)) return;
+    return createHttpContractGateSnapshotStore(input.stateStore.options || {});
+};
+const pickStoreFactory = (mod)=>{
+    if ('function' == typeof mod) return mod;
+    if ('function' == typeof mod.createContractGateSnapshotStore) return mod.createContractGateSnapshotStore;
+    if ('function' == typeof mod.default) return mod.default;
+    if (mod.default && 'object' == typeof mod.default && 'function' == typeof mod.default.createContractGateSnapshotStore) return mod.default.createContractGateSnapshotStore;
+};
+const ensureStoreShape = (store, modulePath)=>{
+    if (!store || 'object' != typeof store || 'function' != typeof store.readSnapshot || 'function' != typeof store.writeSnapshot) throw new Error(`Invalid contract gate snapshot store from "${modulePath}". Expected { readSnapshot(), writeSnapshot() }.`);
+};
+const resolveStoreModulePath = (appDirectory, modulePath)=>{
+    const normalized = modulePath.trim();
+    if (!normalized) throw new Error('Contract gate snapshot stateStore.module must be non-empty');
+    if (path.isAbsolute(normalized)) return normalized;
+    return normalized.startsWith('.') ? path.resolve(appDirectory, normalized) : normalized;
+};
+const resolveContractGateSnapshotPath = (appDirectory, configuredPath)=>{
+    const rawPath = configuredPath || process.env.MODERN_CONTRACT_GATES_FILE || DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH;
+    if (path.isAbsolute(rawPath)) return rawPath;
+    return path.resolve(appDirectory, rawPath);
+};
+const createFileContractGateSnapshotStore = (gateSnapshotPath)=>{
+    const resolvedPath = path.resolve(gateSnapshotPath);
+    return {
+        name: `file:${resolvedPath}`,
+        async readSnapshot () {
+            if (!await fs.pathExists(resolvedPath)) return;
+            try {
+                const raw = await promises.readFile(resolvedPath, 'utf8');
+                return normalizeSnapshot(JSON.parse(raw));
+            } catch (_error) {
+                return;
+            }
+        },
+        async writeSnapshot (snapshot) {
+            const normalized = normalizeSnapshot(snapshot) || {
+                schemaVersion: CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION,
+                updatedAt: Date.now(),
+                gates: {}
+            };
+            await promises.mkdir(path.dirname(resolvedPath), {
+                recursive: true
+            });
+            await promises.writeFile(resolvedPath, `${JSON.stringify(normalized, null, 2)}\n`);
+        }
+    };
+};
+const resolveContractGateSnapshotStore = async (input)=>{
+    const { appDirectory, gateSnapshotPath, stateStore, logger } = input;
+    if (!stateStore?.module) return createFileContractGateSnapshotStore(gateSnapshotPath);
+    const builtinStore = tryResolveBuiltinSnapshotStore({
+        stateStore
+    });
+    if (builtinStore) {
+        logger?.info?.(`[telemetry.canary.autopilot] using built-in contract gate snapshot store "${builtinStore.name}"`);
+        return builtinStore;
+    }
+    const modulePath = resolveStoreModulePath(appDirectory, stateStore.module);
+    let mod;
+    try {
+        mod = require(modulePath);
+    } catch (error) {
+        throw new Error(`[telemetry.canary.autopilot] Failed to load stateStore.module "${stateStore.module}" (${modulePath}): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const factory = pickStoreFactory(mod);
+    if (!factory) throw new Error(`[telemetry.canary.autopilot] stateStore.module "${stateStore.module}" does not export createContractGateSnapshotStore()`);
+    const store = await factory({
+        appDirectory,
+        gateSnapshotPath,
+        options: stateStore.options,
+        logger
+    });
+    ensureStoreShape(store, modulePath);
+    logger?.info?.(`[telemetry.canary.autopilot] using contract gate snapshot store "${store.name || modulePath}"`);
+    return store;
+};
+export { CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION, DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH, createFileContractGateSnapshotStore, createHttpContractGateSnapshotStore, resolveContractGateSnapshotPath, resolveContractGateSnapshotStore };

package/dist/esm/plugins/default.mjs

@@ -0,0 +1,27 @@
+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";
+import { injectTelemetryPlugin } from "./telemetry.mjs";
+function createSilenceLogger() {
+    return new Proxy({}, {
+        get: ()=>()=>{}
+    });
+}
+function createDefaultPlugins(options = {}) {
+    const plugins = [
+        compatPlugin(),
+        logPlugin(),
+        initMonitorsPlugin(),
+        injectTelemetryPlugin(),
+        injectRenderHandlerPlugin(options),
+        injectloggerPlugin(options.logger ? options.logger : createSilenceLogger()),
+        injectServerTiming(),
+        processedByPlugin(),
+        injectRoutePlugin()
+    ];
+    return plugins;
+}
+export { createDefaultPlugins };

package/dist/esm/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/plugins/index.mjs

@@ -0,0 +1,11 @@
+export { compatPlugin, handleSetupResult } from "./compat/index.mjs";
+export { ContractGateAutopilot } from "./contractGateAutopilot.mjs";
+export { CONTRACT_GATE_SNAPSHOT_SCHEMA_VERSION, DEFAULT_CONTRACT_GATE_SNAPSHOT_PATH, createFileContractGateSnapshotStore, createHttpContractGateSnapshotStore, resolveContractGateSnapshotPath, resolveContractGateSnapshotStore } from "./contractGateSnapshotStore.mjs";
+export { createDefaultPlugins } from "./default.mjs";
+export { faviconPlugin } from "./favicon.mjs";
+export { logPlugin } from "./log.mjs";
+export { injectConfigMiddlewarePlugin } from "./middlewares.mjs";
+export { injectServerTiming, injectloggerPlugin } from "./monitors.mjs";
+export { processedByPlugin } from "./processedBy.mjs";
+export { getRenderHandler, injectRenderHandlerPlugin, renderPlugin } from "./render/index.mjs";
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, DEFAULT_RUNTIME_STATUS_ENDPOINT, TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, createOtlpTelemetryExporter, createRuntimeFallbackSignalRuntimeState, createRuntimeSignalError, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, enforceRuntimeFallbackSignalAuthToken, enforceRuntimeFallbackSignalTrustPolicy, getRuntimeSignalErrorStatusCode, hasEnabledTelemetryExporters, injectTelemetryPlugin, normalizeRuntimeFallbackSignalAuthConfig, normalizeRuntimeFallbackTrustPolicy, parseRuntimeFallbackSignalPayloadFromRawBody, resolveRuntimeFallbackSignalEndpoint } from "./telemetry.mjs";

package/dist/esm/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/plugins/mfCache.mjs

@@ -0,0 +1,35 @@
+const REMOTE_ENTRY_REGEXP = /(^|\/)remoteEntry(?:\.[a-zA-Z0-9_-]+)?\.js$/;
+function firstQueryValue(value) {
+    if (Array.isArray(value)) return value.find((item)=>'string' == typeof item && item.length > 0);
+    if ('string' == typeof value && value.length > 0) return value;
+}
+function getRequestPathname(url) {
+    try {
+        return new URL(url, 'http://modernjs.local').pathname;
+    } catch (_error) {
+        return url.split('?')[0] || '/';
+    }
+}
+function isMfManifestAsset(pathname) {
+    return pathname.endsWith('/mf-manifest.json') || pathname.endsWith('/mf-stats.json');
+}
+function isMfRemoteEntryAsset(pathname) {
+    return REMOTE_ENTRY_REGEXP.test(pathname);
+}
+function hasRemoteVersionPin(query = {}) {
+    return Boolean(firstQueryValue(query.mfv) || firstQueryValue(query.v) || firstQueryValue(query.version));
+}
+function resolveMfAssetCacheHeaders(url, query = {}) {
+    const pathname = getRequestPathname(url);
+    if (isMfManifestAsset(pathname)) return {
+        'cache-control': 'no-cache, no-store, must-revalidate',
+        pragma: 'no-cache',
+        expires: '0'
+    };
+    if (isMfRemoteEntryAsset(pathname)) return hasRemoteVersionPin(query) ? {
+        'cache-control': 'public, max-age=31536000, immutable'
+    } : {
+        'cache-control': 'public, max-age=0, must-revalidate'
+    };
+}
+export { getRequestPathname, isMfManifestAsset, isMfRemoteEntryAsset, resolveMfAssetCacheHeaders };

package/dist/esm/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/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/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/plugins/render/csrRscRender.mjs

@@ -0,0 +1,40 @@
+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
+    });
+    const response = await renderRscStreamHandler(req, requestHandlerOptions);
+    return response;
+};
+export { csrRscRender };

package/dist/esm/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/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 };