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

package/dist/esm/libs/metrics.mjs

@@ -0,0 +1,7 @@
+const noop = ()=>{};
+const metrics = {
+    emitCounter: noop,
+    emitTimer: noop,
+    gauges: noop
+};
+export { metrics };

package/dist/esm/libs/render/index.mjs

@@ -0,0 +1,81 @@
+import { cutNameByHyphen, mime } from "@modern-js/utils";
+import path from "path";
+import { ERROR_DIGEST } from "../../constants";
+import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
+import { readFile } from "./reader";
+import { handleDirectory } from "./static";
+import { injectServerData } from "./utils.mjs";
+import * as __rspack_external__ssr_mjs_81ad94dd from "./ssr.mjs";
+const calcFallback = (metaName)=>`x-${cutNameByHyphen(metaName)}-ssr-fallback`;
+const readUnsafeHeaders = (ssrConfig)=>{
+    if (!ssrConfig || 'object' != typeof ssrConfig) return;
+    const unsafeHeaders = ssrConfig.unsafeHeaders;
+    if (!Array.isArray(unsafeHeaders)) return;
+    return unsafeHeaders.filter((header)=>'string' == typeof header && header.trim().length > 0);
+};
+const resolveUnsafeHeaders = (conf, entryName)=>{
+    if (!entryName) return readUnsafeHeaders(conf.server?.ssr);
+    const entrySSRConfig = conf.server?.ssrByEntries?.[entryName];
+    return readUnsafeHeaders(entrySSRConfig) ?? readUnsafeHeaders(conf.server?.ssr);
+};
+const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = 'modern-js' })=>async function({ ctx, route, runner }) {
+        if (ctx.resHasHandled()) return null;
+        const { entryPath, urlPath } = route;
+        const unsafeHeaders = resolveUnsafeHeaders(conf, route.entryName);
+        const entry = path.join(distDir, entryPath);
+        if (!route.isSPA) {
+            const result = await handleDirectory(ctx, entry, urlPath);
+            return result;
+        }
+        const templatePath = entry;
+        const content = await readFile(templatePath);
+        if (!content) return null;
+        const useCSR = forceCSR && (ctx.query.csr || ctx.headers[calcFallback(metaName)]);
+        if (route.isSSR && !useCSR) try {
+            const userAgent = ctx.getReqHeader('User-Agent');
+            const disablePreload = Boolean(ctx.headers[`x-${cutNameByHyphen(metaName)}-disable-preload`]);
+            if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
+                const { flushServerHeader } = await import("../preload");
+                flushServerHeader({
+                    serverConf: conf.server,
+                    ctx,
+                    distDir,
+                    template: content.toString(),
+                    headers: {
+                        'Content-Type': mime.contentType(path.extname(templatePath))
+                    }
+                });
+            }
+            const ssrRenderOptions = {
+                distDir,
+                entryName: route.entryName,
+                urlPath: route.urlPath,
+                bundle: route.bundle,
+                template: content.toString(),
+                staticGenerate,
+                unsafeHeaders,
+                nonce
+            };
+            const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : __rspack_external__ssr_mjs_81ad94dd.render(ctx, {
+                distDir,
+                entryName: route.entryName,
+                urlPath: route.urlPath,
+                bundle: route.bundle,
+                template: content.toString(),
+                staticGenerate,
+                unsafeHeaders,
+                nonce
+            }, runner));
+            return result;
+        } catch (err) {
+            ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
+            ctx.res.set(calcFallback(metaName), '1');
+        }
+        return {
+            content: route.entryName ? injectServerData(content.toString(), ctx, {
+                unsafeHeaders
+            }) : content,
+            contentType: mime.contentType(path.extname(templatePath))
+        };
+    };
+export { createRenderHandler };

package/dist/esm/libs/render/ssr.mjs

@@ -0,0 +1,73 @@
+import { LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME, fs, mime } from "@modern-js/utils";
+import path from "path";
+import cache from "./cache";
+import { createLogger, createMetrics } from "./measure";
+import { injectServerData, injectServerDataStream } from "./utils.mjs";
+const render = async (ctx, renderOptions, runner)=>{
+    const { urlPath, bundle, distDir, template, entryName, staticGenerate, enableUnsafeCtx = false, unsafeHeaders, nonce } = renderOptions;
+    const bundleJS = path.join(distDir, bundle);
+    const loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
+    const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : '';
+    const routesManifestUri = path.join(distDir, ROUTE_MANIFEST_FILE);
+    const routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
+    const context = {
+        request: {
+            baseUrl: urlPath,
+            params: ctx.params,
+            pathname: ctx.path,
+            host: ctx.host,
+            query: ctx.query,
+            url: ctx.href,
+            headers: ctx.headers
+        },
+        response: {
+            setHeader: (key, value)=>ctx.res.setHeader(key, value),
+            status: (code)=>{
+                ctx.res.statusCode = code;
+            },
+            locals: ctx.res?.locals || {}
+        },
+        redirection: {},
+        template,
+        loadableStats,
+        routeManifest,
+        entryName,
+        staticGenerate,
+        logger: void 0,
+        metrics: void 0,
+        reporter: ctx.reporter,
+        serverTiming: ctx.serverTiming,
+        req: ctx.req,
+        res: ctx.res,
+        enableUnsafeCtx,
+        unsafeHeaders,
+        nonce
+    };
+    context.logger = createLogger(context, ctx.logger);
+    context.metrics = createMetrics(context, ctx.metrics);
+    runner.extendSSRContext(context);
+    const bundleJSContent = await Promise.resolve(require(bundleJS));
+    const serverRender = bundleJSContent[SERVER_RENDER_FUNCTION_NAME];
+    const content = await cache(serverRender, ctx)(context);
+    const { url, status = 302 } = context.redirection;
+    if (url) return {
+        content: url,
+        contentType: '',
+        statusCode: status,
+        redirect: true
+    };
+    if ('string' == typeof content) return {
+        content: injectServerData(content, ctx, {
+            unsafeHeaders
+        }),
+        contentType: mime.contentType('html')
+    };
+    return {
+        content: '',
+        contentStream: injectServerDataStream(content, ctx, {
+            unsafeHeaders
+        }),
+        contentType: mime.contentType('html')
+    };
+};
+export { render };

package/dist/esm/libs/render/utils.mjs

@@ -0,0 +1,35 @@
+import { sanitizeSSRPayload } from "@modern-js/runtime-utils/node";
+import { Transform } from "stream";
+const SERVER_DATA_MARKUP = (payload)=>`<script type="application/json" id="__MODERN_SERVER_DATA__">${payload}</script>`;
+const injectIntoHead = (content, payload)=>{
+    const scriptTag = SERVER_DATA_MARKUP(payload);
+    if (content.includes('</head>')) return content.replace('</head>', `${scriptTag}</head>`);
+    return `${scriptTag}${content}`;
+};
+const injectServerData = (content, context, options)=>{
+    const serverData = sanitizeSSRPayload(context.serverData, {
+        unsafeHeaders: options?.unsafeHeaders,
+        treatRootAsHeaders: true
+    }).payload;
+    return injectIntoHead(content, JSON.stringify(serverData));
+};
+const injectServerDataStream = (content, context, options)=>{
+    const serverData = sanitizeSSRPayload(context.serverData, {
+        unsafeHeaders: options?.unsafeHeaders,
+        treatRootAsHeaders: true
+    }).payload;
+    const payload = JSON.stringify(serverData);
+    let buffer = '';
+    const injector = new Transform({
+        transform (chunk, _encoding, callback) {
+            buffer += chunk.toString();
+            callback();
+        },
+        flush (callback) {
+            this.push(injectIntoHead(buffer, payload));
+            callback();
+        }
+    });
+    return content.pipe(injector);
+};
+export { injectServerData, injectServerDataStream };

package/dist/esm/libs/runtimeFallbackWorkerLane.mjs

@@ -0,0 +1,130 @@
+import { Worker } from "node:worker_threads";
+const DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS = 250;
+const WORKER_SCRIPT = `
+const { parentPort, workerData } = require('node:worker_threads');
+const fs = require('node:fs/promises');
+const path = require('node:path');
+
+const isRecord = value => typeof value === 'object' && value !== null && !Array.isArray(value);
+
+const main = async () => {
+  const now = Date.now();
+  const snapshotPath = String(workerData.snapshotPath || '');
+  const gateName = String(workerData.gateName || 'runtime-mf-fallback-health');
+  const failureHoldMsRaw = Number(workerData.failureHoldMs);
+  const failureHoldMs = Number.isFinite(failureHoldMsRaw) && failureHoldMsRaw > 0
+    ? Math.floor(failureHoldMsRaw)
+    : 300000;
+  const schemaVersionRaw = Number(workerData.schemaVersion);
+  const schemaVersion = Number.isFinite(schemaVersionRaw) ? schemaVersionRaw : 1;
+  const payload = isRecord(workerData.payload) ? workerData.payload : {};
+
+  let snapshot = {
+    schemaVersion,
+    updatedAt: now,
+    gates: {},
+  };
+
+  try {
+    const raw = await fs.readFile(snapshotPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (isRecord(parsed)) {
+      snapshot = {
+        schemaVersion: typeof parsed.schemaVersion === 'number' ? parsed.schemaVersion : schemaVersion,
+        updatedAt: typeof parsed.updatedAt === 'number' ? parsed.updatedAt : now,
+        gates: isRecord(parsed.gates) ? parsed.gates : {},
+      };
+    }
+  } catch (_error) {
+    // start from empty snapshot when file does not exist or cannot be parsed
+  }
+
+  const reason = typeof payload.reason === 'string' ? payload.reason : 'runtime_fallback';
+  const phase = typeof payload.phase === 'string' ? payload.phase : 'unknown';
+  const appName = typeof payload.appName === 'string' ? payload.appName : 'unknown';
+  const entry = typeof payload.entry === 'string' ? payload.entry : undefined;
+
+  snapshot.schemaVersion = schemaVersion;
+  snapshot.updatedAt = now;
+  snapshot.gates = isRecord(snapshot.gates) ? snapshot.gates : {};
+  snapshot.gates[gateName] = {
+    passed: false,
+    reason: \`runtime_fallback:\${reason} phase=\${phase} app=\${appName}\${entry ? \` entry=\${entry}\` : ''}\`,
+    updatedAt: now,
+    expiresAt: now + failureHoldMs,
+    source: 'runtime-mf-fallback-signal',
+    metadata: payload,
+  };
+
+  await fs.mkdir(path.dirname(snapshotPath), { recursive: true });
+  await fs.writeFile(snapshotPath, JSON.stringify(snapshot, null, 2) + '\\n');
+
+  return {
+    ok: true,
+  };
+};
+
+main()
+  .then(result => {
+    parentPort.postMessage(result);
+  })
+  .catch(error => {
+    parentPort.postMessage({
+      ok: false,
+      error: error && error.message ? error.message : String(error),
+    });
+  });
+`;
+const normalizeErrorMessage = (error)=>{
+    if (error instanceof Error) return error.message;
+    return String(error);
+};
+const persistRuntimeFallbackContractGateInWorker = async (payload, config)=>{
+    if (!config.enabled) return {
+        ok: false,
+        error: 'worker_lane_disabled'
+    };
+    return new Promise((resolve)=>{
+        let settled = false;
+        const worker = new Worker(WORKER_SCRIPT, {
+            eval: true,
+            workerData: payload
+        });
+        const finish = (result)=>{
+            if (settled) return;
+            settled = true;
+            clearTimeout(timeoutId);
+            worker.terminate().catch(()=>{});
+            resolve(result);
+        };
+        const timeoutId = setTimeout(()=>{
+            finish({
+                ok: false,
+                error: 'worker_lane_timeout'
+            });
+        }, Math.max(25, config.timeoutMs));
+        worker.once('message', (message)=>{
+            if (message && 'object' == typeof message && true === message.ok) return void finish({
+                ok: true
+            });
+            finish({
+                ok: false,
+                error: message && 'object' == typeof message && 'error' in message ? String(message.error || 'worker_error') : 'worker_error'
+            });
+        });
+        worker.once('error', (error)=>{
+            finish({
+                ok: false,
+                error: normalizeErrorMessage(error)
+            });
+        });
+        worker.once('exit', (code)=>{
+            if (settled || 0 === code) return;
+            finish({
+                ok: false,
+                error: `worker_lane_exit_${String(code)}`
+            });
+        });
+    });
+};
+export { DEFAULT_RUNTIME_FALLBACK_WORKER_TIMEOUT_MS, persistRuntimeFallbackContractGateInWorker };

package/dist/esm/libs/telemetry.mjs

@@ -0,0 +1 @@
+export { DEFAULT_RUNTIME_FALLBACK_SIGNAL_ENDPOINT, DEFAULT_RUNTIME_STATUS_ENDPOINT, TelemetryCanaryOrchestrator, TelemetryRegistry, TelemetryStartupHealthError, createOtlpTelemetryExporter, createRuntimeFallbackSignalRuntimeState, createRuntimeSignalError, createTelemetryAwareMetrics, createVictoriaMetricsTelemetryExporter, enforceRuntimeFallbackSignalAuthToken, enforceRuntimeFallbackSignalTrustPolicy, getRuntimeSignalErrorStatusCode, hasEnabledTelemetryExporters, normalizeRuntimeFallbackSignalAuthConfig, normalizeRuntimeFallbackTrustPolicy, parseRuntimeFallbackSignalPayloadFromRawBody, resolveRuntimeFallbackSignalEndpoint } from "@modern-js/server-core";

package/dist/esm/netlify.mjs

@@ -0,0 +1,22 @@
+import { createServerBase } from "@modern-js/server-core";
+import { loadServerCliConfig, loadServerEnv, loadServerRuntimeConfig } from "@modern-js/server-core/node";
+import { applyPlugins } from "./apply.mjs";
+const createNetlifyFunction = async (options)=>{
+    await loadServerEnv(options);
+    const serverBaseOptions = options;
+    const serverCliConfig = loadServerCliConfig(options.pwd, options.config);
+    if (serverCliConfig) options.config = serverCliConfig;
+    const serverRuntimeConfig = await loadServerRuntimeConfig(options.serverConfigPath);
+    if (serverRuntimeConfig) {
+        serverBaseOptions.serverConfig = serverRuntimeConfig;
+        serverBaseOptions.plugins = [
+            ...serverRuntimeConfig.plugins || [],
+            ...options.plugins || []
+        ];
+    }
+    const server = createServerBase(serverBaseOptions);
+    await applyPlugins(server, options);
+    await server.init();
+    return (request, context)=>server.handle(request, context);
+};
+export { createNetlifyFunction };

package/dist/esm/rslib-runtime.mjs

@@ -0,0 +1,18 @@
+var __webpack_modules__ = {};
+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;
+}
+__webpack_require__.m = __webpack_modules__;
+(()=>{
+    __webpack_require__.add = function(modules) {
+        Object.assign(__webpack_require__.m, modules);
+    };
+})();
+export { __webpack_require__ };