@modern-js/server-core 2.48.5-alpha.1 → 2.48.5

package/dist/esm-node/base/middlewares/customServer/index.js

@@ -1,106 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import { transformResponse } from "../../utils";
-import { ServerReportTimings } from "../../constants";
-import { getAfterMatchCtx, getAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
-import { createBaseHookContext } from "./base";
-const noop = () => {
-};
-const isHtmlResponse = (response) => {
-  const contentType = response.headers.get("content-type");
-  return contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/html");
-};
-class CustomServer {
-  getHookMiddleware(entryName, routes) {
-    return async (c, next) => {
-      const routeInfo = routes.find((route) => route.entryName === entryName);
-      const reporter = c.get("reporter");
-      const baseHookCtx = createBaseHookContext(c);
-      const afterMatchCtx = getAfterMatchCtx(entryName, baseHookCtx);
-      const getCost = time();
-      await this.runner.afterMatch(afterMatchCtx, {
-        onLast: noop
-      });
-      const cost = getCost();
-      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost));
-      const { url, status } = afterMatchCtx.router;
-      if (url) {
-        return c.redirect(url, status);
-      }
-      const { current } = afterMatchCtx.router;
-      if (current !== entryName) {
-        const rewriteRoute = routes.find((route) => route.entryName === current);
-        if (rewriteRoute) {
-          return this.serverBase.request(rewriteRoute.urlPath);
-        }
-      }
-      if (c.finalized) {
-        return void 0;
-      }
-      await next();
-      if (c.finalized && (!c.res.body || !isHtmlResponse(c.res))) {
-        return void 0;
-      }
-      if (routeInfo.isStream) {
-        const afterStreamingRenderContext = createAfterStreamingRenderContext(baseHookCtx, routeInfo);
-        c.res = transformResponse(c.res, (chunk) => {
-          const context = afterStreamingRenderContext(chunk);
-          return this.runner.afterStreamingRender(context, {
-            onLast: ({ chunk: chunk2 }) => chunk2
-          });
-        });
-      } else {
-        const afterRenderCtx = await getAfterRenderCtx(c, baseHookCtx, routeInfo);
-        const getCost2 = time();
-        await this.runner.afterRender(afterRenderCtx, {
-          onLast: noop
-        });
-        const cost2 = getCost2();
-        cost2 && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost2));
-        if (afterRenderCtx.response.private_overrided) {
-          return void 0;
-        }
-        const newBody = afterRenderCtx.template.get();
-        c.res = c.body(newBody);
-      }
-    };
-  }
-  getServerMiddleware() {
-    return async (c, next) => {
-      var _c_env;
-      const serverMiddleware = await this.serverMiddlewarePromise;
-      if (!serverMiddleware) {
-        return next();
-      }
-      const reporter = c.get("reporter");
-      const locals = {};
-      const customMiddlewareCtx = createCustomMiddlewaresCtx(c, locals);
-      const getCost = time();
-      await serverMiddleware(customMiddlewareCtx);
-      const cost = getCost();
-      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost));
-      c.set("locals", locals);
-      if ((_c_env = c.env) === null || _c_env === void 0 ? void 0 : _c_env.node.res.headersSent) {
-        return void 0;
-      }
-      if (!c.finalized) {
-        return next();
-      }
-    };
-  }
-  constructor(runner, serverBase, pwd) {
-    this.runner = runner;
-    this.serverBase = serverBase;
-    const webExtension = [];
-    this.serverMiddlewarePromise = runner.prepareWebServer({
-      pwd,
-      config: {
-        middleware: webExtension
-      }
-    }, {
-      onLast: () => null
-    });
-  }
-}
-export {
-  CustomServer
-};

package/dist/esm-node/base/middlewares/customServer/routerApi.js

@@ -1,20 +0,0 @@
-class RouterAPI {
-  redirect(url, status = 302) {
-    this.url = url;
-    this.status = status;
-  }
-  rewrite(entryName) {
-    this.current = entryName;
-  }
-  use(entryName) {
-    this.rewrite(entryName);
-  }
-  constructor(entryName) {
-    this.current = entryName;
-    this.status = 200;
-    this.url = "";
-  }
-}
-export {
-  RouterAPI
-};

package/dist/esm-node/base/middlewares/customServer/template.js

@@ -1,34 +0,0 @@
-import { REPLACE_REG } from "../../constants";
-class TemplateApi {
-  set(content) {
-    this.body = content;
-  }
-  get() {
-    return this.body;
-  }
-  prependHead(fragment) {
-    const { head } = REPLACE_REG.before;
-    this.replaceBody(new RegExp(head), (beforeHead) => `${beforeHead}${fragment}`);
-  }
-  appendHead(fragment) {
-    const { head } = REPLACE_REG.after;
-    this.replaceBody(head, () => `${fragment}${head}`);
-  }
-  prependBody(fragment) {
-    const { body } = REPLACE_REG.before;
-    this.replaceBody(new RegExp(body), (beforeBody) => `${beforeBody}${fragment}`);
-  }
-  appendBody(fragment) {
-    const { body } = REPLACE_REG.after;
-    this.replaceBody(body, () => `${fragment}${body}`);
-  }
-  replaceBody(searchValue, replaceCb) {
-    this.body = this.body.replace(searchValue, replaceCb);
-  }
-  constructor(body) {
-    this.body = body;
-  }
-}
-export {
-  TemplateApi
-};

package/dist/esm-node/base/middlewares/faviconFallback.js

@@ -1,10 +0,0 @@
-const favionFallbackMiddleware = async (c, next) => {
-  if (c.req.path === "/favicon.ico") {
-    return c.body(null, 204);
-  } else {
-    return next();
-  }
-};
-export {
-  favionFallbackMiddleware
-};

package/dist/esm-node/base/middlewares/frameworkHeader.js

@@ -1,7 +0,0 @@
-const processedBy = async (ctx, next) => {
-  await next();
-  ctx.header("X-Processed-By", "Modern.js");
-};
-export {
-  processedBy
-};

package/dist/esm-node/base/middlewares/index.js

@@ -1,5 +0,0 @@
-export * from "./faviconFallback";
-export * from "./monitor";
-export * from "./renderHandler";
-export * from "./logger";
-export * from "./frameworkHeader";

package/dist/esm-node/base/middlewares/logger.js

@@ -1,53 +0,0 @@
-import { getPathname } from "../utils";
-var LogPrefix;
-(function(LogPrefix2) {
-  LogPrefix2["Outgoing"] = "-->";
-  LogPrefix2["Incoming"] = "<--";
-  LogPrefix2["Error"] = "xxx";
-})(LogPrefix || (LogPrefix = {}));
-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 < 1e3 ? `${delta}ms` : `${Math.round(delta / 1e3)}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 logger(c, next) {
-    const { method } = c.req;
-    const logger2 = c.get("logger");
-    const path = getPathname(c.req.raw);
-    const logFn = logger2.info;
-    log(logFn, "<--", method, path);
-    const start = Date.now();
-    await next();
-    log(logFn, "-->", method, path, c.res.status, time(start));
-  };
-}
-export {
-  logHandler
-};

package/dist/esm-node/base/middlewares/monitor.js

@@ -1,63 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import { ServerReportTimings } from "../constants";
-const defaultReporter = {
-  init() {
-  },
-  reportError() {
-  },
-  reportTiming() {
-  },
-  reportInfo() {
-  },
-  reportWarn() {
-  }
-};
-function injectReporter() {
-  return async (c, next) => {
-    const reporter = c.get("reporter");
-    if (!reporter) {
-      c.set("reporter", defaultReporter);
-    }
-    await next();
-  };
-}
-function initReporter(entryName) {
-  return async (c, next) => {
-    const reporter = c.get("reporter");
-    if (!reporter) {
-      await next();
-      return;
-    }
-    await reporter.init({
-      entryName
-    });
-    const getCost = time();
-    await next();
-    const cost = getCost();
-    reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
-  };
-}
-function injectLogger(inputLogger) {
-  return async (c, next) => {
-    const logger = c.get("logger");
-    if (!logger && inputLogger) {
-      c.set("logger", inputLogger);
-    }
-    await next();
-  };
-}
-function injectMetrics(inputMetrics) {
-  return async (c, next) => {
-    const metrics = c.get("metrics");
-    if (!metrics) {
-      c.set("metrics", inputMetrics);
-    }
-    await next();
-  };
-}
-export {
-  initReporter,
-  injectLogger,
-  injectMetrics,
-  injectReporter
-};

package/dist/esm-node/base/middlewares/renderHandler/dataHandler.js

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

package/dist/esm-node/base/middlewares/renderHandler/index.js

@@ -1,71 +0,0 @@
-import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
-import { initReporter } from "../monitor";
-import { CustomServer } from "../customServer";
-import { createRender } from "./render";
-function createRenderHandler(render) {
-  return async (c, _) => {
-    var _c_env_node;
-    const logger = c.get("logger");
-    const reporter = c.get("reporter");
-    const templates = c.get("templates") || {};
-    const serverManifest = c.get("serverManifest") || {};
-    const locals = c.get("locals");
-    const request = c.req.raw;
-    const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
-    const res = await render(request, {
-      logger,
-      nodeReq,
-      reporter,
-      templates,
-      serverManifest,
-      locals
-    });
-    return res;
-  };
-}
-async function getRenderHandler(options) {
-  const { routes, pwd, config } = options;
-  if (routes && routes.length > 0) {
-    var _config_server, _options_config_security;
-    const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
-    const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
-    const render = createRender({
-      routes,
-      pwd,
-      staticGenerate: options.staticGenerate,
-      metaName: options.metaName || "modern-js",
-      forceCSR,
-      nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce
-    });
-    return render;
-  }
-  return null;
-}
-async function bindRenderHandler(server, options) {
-  const { routes, pwd, disableCustomHook } = options;
-  const { runner } = server;
-  if (routes && routes.length > 0) {
-    const customServer = new CustomServer(runner, server, pwd);
-    if (getRuntimeEnv() === "node") {
-      const cacheModuleName = "./ssrCache";
-      const { ssrCache } = await import(cacheModuleName);
-      await ssrCache.loadCacheMod(checkIsProd() ? pwd : void 0);
-    }
-    const pageRoutes = routes.filter((route) => !route.isApi).sort(sortRoutes);
-    const render = await getRenderHandler(options);
-    for (const route of pageRoutes) {
-      const { urlPath: originUrlPath, entryName } = route;
-      const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
-      const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
-      server.use(urlPath, initReporter(entryName));
-      !disableCustomHook && server.use(urlPath, customServerHookMiddleware);
-      const customServerMiddleware = customServer.getServerMiddleware();
-      server.use(urlPath, customServerMiddleware);
-      render && server.all(urlPath, createRenderHandler(render));
-    }
-  }
-}
-export {
-  bindRenderHandler,
-  getRenderHandler
-};

package/dist/esm-node/base/middlewares/renderHandler/render.js

@@ -1,102 +0,0 @@
-import { cutNameByHyphen } from "@modern-js/utils/universal";
-import { REPLACE_REG } from "../../../base/constants";
-import { createErrorHtml, sortRoutes, parseQuery, transformResponse, getPathname } from "../../utils";
-import { dataHandler } from "./dataHandler";
-import { ssrRender } from "./ssrRender";
-async function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce }) {
-  return async (req, { logger, nodeReq, reporter, templates, serverManifest, locals }) => {
-    const routeInfo = matchRoute(req, routes);
-    if (!routeInfo) {
-      return new Response(createErrorHtml(404), {
-        status: 404,
-        headers: {
-          "content-type": "text/html; charset=UTF-8"
-        }
-      });
-    }
-    const html = templates[routeInfo.entryName];
-    if (!html) {
-      throw new Error(`Can't found entry ${routeInfo.entryName} html `);
-    }
-    const renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR, nodeReq);
-    const renderOptions = {
-      pwd,
-      html,
-      routeInfo,
-      staticGenerate: staticGenerate || false,
-      metaName: metaName || "modern-js",
-      nonce,
-      logger,
-      nodeReq,
-      reporter,
-      serverRoutes: routes,
-      locals,
-      serverManifest
-    };
-    switch (renderMode) {
-      case "data":
-        let response = await dataHandler(req, renderOptions);
-        if (!response) {
-          response = await renderHandler(req, renderOptions, "ssr");
-        }
-        return response;
-      case "ssr":
-      case "csr":
-        return renderHandler(req, renderOptions, renderMode);
-      default:
-        throw new Error(`Unknown render mode: ${renderMode}`);
-    }
-  };
-}
-async function renderHandler(request, options, mode) {
-  const serverData = {
-    router: {
-      baseUrl: options.routeInfo.urlPath,
-      params: {}
-    }
-  };
-  const response = await (mode === "ssr" ? ssrRender(request, options) : csrRender(options.html));
-  return transformResponse(response, injectServerData(serverData));
-}
-function matchRoute(req, routes) {
-  const sorted = routes.sort(sortRoutes);
-  for (const route of sorted) {
-    const pathname = getPathname(req);
-    if (pathname.startsWith(route.urlPath)) {
-      return route;
-    }
-  }
-  return void 0;
-}
-function getRenderMode(req, framework, isSSR, forceCSR, nodeReq) {
-  const query = parseQuery(req);
-  const fallbackHeader = `x-${cutNameByHyphen(framework)}-ssr-fallback`;
-  if (isSSR) {
-    if (query.__loader) {
-      return "data";
-    }
-    if (forceCSR && (query.csr || req.headers.get(fallbackHeader) || (nodeReq === null || nodeReq === void 0 ? void 0 : nodeReq.headers[fallbackHeader]))) {
-      return "csr";
-    }
-    return "ssr";
-  } else {
-    return "csr";
-  }
-}
-function csrRender(html) {
-  return new Response(html, {
-    status: 200,
-    headers: new Headers({
-      "content-type": "text/html; charset=UTF-8"
-    })
-  });
-}
-function injectServerData(serverData) {
-  const { head } = REPLACE_REG.before;
-  const searchValue = new RegExp(head);
-  const replcaeCb = (beforeHead) => `${beforeHead}<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(serverData)}</script>`;
-  return (template) => template.replace(searchValue, replcaeCb);
-}
-export {
-  createRender
-};

package/dist/esm-node/base/middlewares/renderHandler/serverTiming.js

@@ -1,16 +0,0 @@
-const SERVER_TIMING = "Server-Timing";
-class ServerTiming {
-  addServeTiming(name, dur, desc) {
-    const _name = `bd-${this.meta}-${name}`;
-    const value = `${_name};${desc ? `decs="${desc}";` : ""} dur=${dur}`;
-    this.headers.append(SERVER_TIMING, value);
-    return this;
-  }
-  constructor(headers, meta) {
-    this.meta = meta;
-    this.headers = headers;
-  }
-}
-export {
-  ServerTiming
-};

package/dist/esm-node/base/middlewares/renderHandler/ssrCache.js

@@ -1,162 +0,0 @@
-import { Readable } from "stream";
-import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
-import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { createReadableStreamFromReadable } from "../../adapters/node/polyfills/stream";
-import { createTransformStream, getPathname } from "../../utils";
-class CacheManager {
-  async getCacheResult(req, cacheControl, render, ssrContext) {
-    const key = this.computedKey(req, cacheControl);
-    const value = await this.container.get(key);
-    const { maxAge, staleWhileRevalidate } = cacheControl;
-    const ttl = maxAge + staleWhileRevalidate;
-    if (value) {
-      const cache = JSON.parse(value);
-      const interval = Date.now() - cache.cursor;
-      if (interval <= maxAge) {
-        return {
-          data: cache.val,
-          status: "hit"
-        };
-      } else if (interval <= staleWhileRevalidate + maxAge) {
-        this.processCache(key, render, ssrContext, ttl);
-        return {
-          data: cache.val,
-          status: "stale"
-        };
-      } else {
-        return this.processCache(key, render, ssrContext, ttl, "expired");
-      }
-    } else {
-      return this.processCache(key, render, ssrContext, ttl, "miss");
-    }
-  }
-  async processCache(key, render, ssrContext, ttl, status) {
-    const renderResult = await render(ssrContext);
-    if (!renderResult) {
-      return {
-        data: ""
-      };
-    } else if (typeof renderResult === "string") {
-      const current = Date.now();
-      const cache = {
-        val: renderResult,
-        cursor: current
-      };
-      await this.container.set(key, JSON.stringify(cache), {
-        ttl
-      });
-      return {
-        data: renderResult,
-        status
-      };
-    } else {
-      const body = (
-        // TODO: remove node:stream, move it to ssr entry.
-        renderResult instanceof Readable ? createReadableStreamFromReadable(renderResult) : renderResult
-      );
-      let html = "";
-      const stream = createTransformStream((chunk) => {
-        html += chunk;
-        return chunk;
-      });
-      stream.readable.getReader().closed.then(() => {
-        const current = Date.now();
-        const cache = {
-          val: html,
-          cursor: current
-        };
-        this.container.set(key, JSON.stringify(cache), {
-          ttl
-        });
-      });
-      body.pipeThrough(stream);
-      return {
-        data: stream.readable,
-        status
-      };
-    }
-  }
-  computedKey(req, cacheControl) {
-    const pathname = getPathname(req);
-    const { customKey } = cacheControl;
-    const defaultKey = pathname.replace(/.+\/+$/, "");
-    if (customKey) {
-      if (typeof customKey === "string") {
-        return customKey;
-      } else {
-        return customKey(defaultKey);
-      }
-    } else {
-      return defaultKey;
-    }
-  }
-  constructor(container) {
-    this.container = container;
-  }
-}
-const CACHE_FILENAME = "cache";
-class ServerCache {
-  async loadCacheMod(pwd = process.cwd()) {
-    const path = await import("path").catch(() => {
-      return {};
-    });
-    const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-    const mod = requireExistModule(serverCacheFilepath, {
-      interop: false
-    });
-    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
-    if (this.cacheOption && !(mod === null || mod === void 0 ? void 0 : mod.customContainer)) {
-      const cacheStorage = createMemoryStorage("__ssr__cache");
-      this.customContainer = cacheStorage;
-    } else {
-      this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
-    }
-    if (this.customContainer) {
-      this.cacheManger = new CacheManager(this.customContainer);
-    }
-  }
-  matchCacheControl(req) {
-    const { cacheOption } = this;
-    if (!cacheOption || !req) {
-      return void 0;
-    } else if (isCacheControl(cacheOption)) {
-      return cacheOption;
-    } else if (isCacheOptionProvider(cacheOption)) {
-      return cacheOption(req);
-    } else {
-      const url = req.url;
-      const options = Object.entries(cacheOption);
-      for (const [key, option] of options) {
-        if (key === "*" || new RegExp(key).test(url)) {
-          if (typeof option === "function") {
-            return option(req);
-          } else {
-            return option;
-          }
-        }
-      }
-      return void 0;
-    }
-    function isCacheOptionProvider(option) {
-      return typeof option === "function";
-    }
-    function isCacheControl(option) {
-      return typeof option === "object" && option !== null && "maxAge" in option;
-    }
-  }
-  async getCache(req, cacheControl, render, ssrContext) {
-    if (this.cacheManger) {
-      return this.cacheManger.getCacheResult(req, cacheControl, render, ssrContext);
-    } else {
-      const renderResult = await render(ssrContext);
-      return {
-        data: renderResult
-      };
-    }
-  }
-}
-const ssrCache = new ServerCache();
-export {
-  CacheManager,
-  ssrCache
-};