@modern-js/server-core 2.47.0 → 2.47.1-alpha.0

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

@@ -0,0 +1,114 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { time } from "@modern-js/runtime-utils/time";
+import { createTransformStream } from "../../utils";
+import { ServerReportTimings } from "../../constants";
+import { createAfterMatchCtx, createAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
+const noop = () => {
+};
+class CustomServer {
+  getHookMiddleware(entryName, routes) {
+    return async (c, next) => {
+      const routeInfo = routes.find((route) => route.entryName === entryName);
+      const logger = c.get("logger");
+      const reporter = c.get("reporter");
+      const metrics = c.get("metrics");
+      const afterMatchCtx = createAfterMatchCtx(c, entryName, logger, metrics);
+      const getCost = time();
+      await this.runner.afterMatch(afterMatchCtx, {
+        onLast: noop
+      });
+      const cost = getCost();
+      cost && reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost);
+      const {
+        // current,
+        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) {
+        return void 0;
+      }
+      if (routeInfo.isStream) {
+        var _c_res_body;
+        const afterStreamingRenderContext = createAfterStreamingRenderContext(c, logger, routeInfo, metrics);
+        const injectStream = createTransformStream((chunk) => {
+          const context = afterStreamingRenderContext(chunk);
+          return this.runner.afterStreamingRender(context, {
+            onLast: ({ chunk: chunk2 }) => chunk2
+          });
+        });
+        (_c_res_body = c.res.body) === null || _c_res_body === void 0 ? void 0 : _c_res_body.pipeThrough(injectStream);
+        const { headers, status: status2, statusText } = c.res;
+        c.res = c.body(injectStream.readable, {
+          headers,
+          status: status2,
+          statusText
+        });
+      } else {
+        const afterRenderCtx = await createAfterRenderCtx(c, logger, metrics);
+        const getCost2 = time();
+        await this.runner.afterRender(afterRenderCtx, {
+          onLast: noop
+        });
+        const cost2 = getCost2();
+        cost2 && 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) => {
+      const serverMiddleware = await this.serverMiddlewarePromise;
+      if (!serverMiddleware) {
+        return next();
+      }
+      const reporter = c.get("reporter");
+      const logger = c.get("logger");
+      const metrics = c.get("metrics");
+      const customMiddlewareCtx = createCustomMiddlewaresCtx(c, logger, metrics);
+      const getCost = time();
+      await serverMiddleware(customMiddlewareCtx);
+      const cost = getCost();
+      cost && reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost);
+      if (!c.finalized) {
+        return next();
+      }
+    };
+  }
+  constructor(runner, serverBase, pwd) {
+    _define_property(this, "runner", void 0);
+    _define_property(this, "serverMiddlewarePromise", void 0);
+    _define_property(this, "serverBase", void 0);
+    this.runner = runner;
+    this.serverBase = serverBase;
+    const webExtension = [];
+    this.serverMiddlewarePromise = runner.prepareWebServer({
+      pwd,
+      config: {
+        middleware: webExtension
+      }
+    }, {
+      onLast: () => null
+    });
+  }
+}
+export {
+  CustomServer
+};

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

@@ -0,0 +1,24 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+class RouterAPI {
+  redirect(url, status = 302) {
+    this.url = url;
+    this.status = status;
+  }
+  rewrite(entryName) {
+    this.current = entryName;
+  }
+  use(entryName) {
+    this.rewrite(entryName);
+  }
+  constructor(entryName) {
+    _define_property(this, "current", void 0);
+    _define_property(this, "status", void 0);
+    _define_property(this, "url", void 0);
+    this.current = entryName;
+    this.status = 200;
+    this.url = "";
+  }
+}
+export {
+  RouterAPI
+};

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

@@ -0,0 +1,36 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+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) {
+    _define_property(this, "body", void 0);
+    this.body = body;
+  }
+}
+export {
+  TemplateApi
+};

package/dist/esm/base/middlewares/dataHandler.js

@@ -0,0 +1,35 @@
+import { MAIN_ENTRY_NAME, SERVER_BUNDLE_DIRECTORY } from "@modern-js/utils";
+import { getPathModule, sortRoutes } from "../utils";
+const bindDataHandlers = async (server, routes, distDir) => {
+  const path = await getPathModule();
+  routes.sort(sortRoutes).forEach((route) => {
+    const bundlePath = path.join(distDir, SERVER_BUNDLE_DIRECTORY, `${route.entryName || MAIN_ENTRY_NAME}-server-loaders.js`);
+    server.all(`${route.urlPath === "/" ? "*" : `${route.urlPath}/*`}`, createDataHandler(routes, bundlePath));
+  });
+};
+const createDataHandler = (serverRoutes, buildModulePath) => {
+  return async (context, next) => {
+    let buildModule;
+    try {
+      buildModule = await import(buildModulePath);
+    } catch (_) {
+      return next();
+    }
+    const { routes, handleRequest } = buildModule;
+    const logger = context.get("logger");
+    const reporter = context.get("reporter");
+    const response = await handleRequest({
+      request: context.req.raw,
+      serverRoutes,
+      context: {
+        logger,
+        reporter
+      },
+      routes
+    });
+    return response ? response : next();
+  };
+};
+export {
+  bindDataHandlers
+};

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

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

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

@@ -0,0 +1,4 @@
+export * from "./faviconFallback";
+export * from "./dataHandler";
+export * from "./monitor";
+export * from "./renderHandler";

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

@@ -0,0 +1,49 @@
+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");
+    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();
+  };
+}
+export {
+  initReporter,
+  injectLogger,
+  injectReporter
+};

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

@@ -0,0 +1,67 @@
+import { warmup, checkIsProd, sortRoutes, getPathModule } from "../../utils";
+import { initReporter } from "../monitor";
+import { CustomServer } from "../customServer";
+import { ssrCache } from "./ssrCache";
+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 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 templates = c.get("templates");
+    const res = await render(request, {
+      logger,
+      nodeReq,
+      reporter,
+      tpls: templates || {}
+    });
+    return res;
+  };
+}
+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 } = options;
+  const path = await getPathModule();
+  const { runner } = server;
+  if (routes && routes.length > 0) {
+    const customServer = new CustomServer(runner, server, pwd);
+    const ssrBundles = routes.filter((route) => route.isSSR && route.bundle).map((route) => path.join(pwd, route.bundle));
+    warmup(ssrBundles);
+    await ssrCache.loadCacheMod(checkIsProd() ? pwd : void 0);
+    const pageRoutes = routes.filter((route) => !route.isApi).sort(sortRoutes);
+    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));
+      server.use(urlPath, customServerHookMiddleware);
+      const customServerMiddleware = customServer.getServerMiddleware();
+      server.use(urlPath, customServerMiddleware);
+    }
+    const render = getRenderHandler(options);
+    render && server.get("*", createRenderHandler(render));
+  }
+}
+export {
+  bindRenderHandler,
+  getRenderHandler
+};

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

@@ -0,0 +1,66 @@
+import { cutNameByHyphen } from "@modern-js/utils";
+import { parseQuery } from "../../utils/request";
+import { createErrorHtml, sortRoutes } from "../../utils";
+import { ssrRender } from "./ssrRender";
+function createRender({ routes, pwd, metaName, staticGenerate, forceCSR, nonce }) {
+  return async (req, { logger, nodeReq, reporter, tpls }) => {
+    const routeInfo = matchRoute(req, routes);
+    if (!routeInfo) {
+      return new Response(createErrorHtml(404), {
+        status: 404,
+        headers: {
+          "content-type": "text/html; charset=UTF-8"
+        }
+      });
+    }
+    const html = tpls[routeInfo.entryName];
+    if (!html) {
+      throw new Error(`Can't found entry ${routeInfo.entryName} html `);
+    }
+    const renderMode = getRenderMode(req, metaName || "modern-js", routeInfo.isSSR, forceCSR);
+    return renderMode === "csr" ? csrRender(html) : ssrRender(req, {
+      pwd,
+      mode: "string",
+      html,
+      routeInfo,
+      staticGenerate: staticGenerate || false,
+      metaName: metaName || "modern-js",
+      nonce,
+      logger,
+      nodeReq,
+      reporter
+    });
+  };
+}
+function matchRoute(req, routes) {
+  const sorted = routes.sort(sortRoutes);
+  for (const route of sorted) {
+    const reg = new RegExp(route.urlPath);
+    if (reg.test(req.url)) {
+      return route;
+    }
+  }
+  return void 0;
+}
+function getRenderMode(req, framework, isSSR, forceCSR) {
+  const query = parseQuery(req);
+  if (isSSR) {
+    if (forceCSR && (query.csr || req.headers.get(`x-${cutNameByHyphen(framework)}-ssr-fallback`))) {
+      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"
+    })
+  });
+}
+export {
+  createRender
+};

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

@@ -0,0 +1,19 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+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) {
+    _define_property(this, "headers", void 0);
+    _define_property(this, "meta", void 0);
+    this.meta = meta;
+    this.headers = headers;
+  }
+}
+export {
+  ServerTiming
+};

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

@@ -0,0 +1,149 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+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, getPathModule, 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 cache.val;
+      } else if (interval <= staleWhileRevalidate + maxAge) {
+        this.processCache(key, render, ssrContext, ttl);
+        return cache.val;
+      } else {
+        return this.processCache(key, render, ssrContext, ttl);
+      }
+    } else {
+      return this.processCache(key, render, ssrContext, ttl);
+    }
+  }
+  async processCache(key, render, ssrContext, ttl) {
+    const renderResult = await render(ssrContext);
+    if (!renderResult) {
+      return "";
+    } 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 renderResult;
+    } 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 stream.readable;
+    }
+  }
+  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) {
+    _define_property(this, "container", void 0);
+    this.container = container;
+  }
+}
+const CACHE_FILENAME = "cache";
+class ServerCache {
+  async loadCacheMod(pwd = process.cwd()) {
+    const path = await getPathModule();
+    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;
+    }
+  }
+  getCache(req, cacheControl, render, ssrContext) {
+    if (this.cacheManger) {
+      return this.cacheManger.getCacheResult(req, cacheControl, render, ssrContext);
+    } else {
+      return render(ssrContext);
+    }
+  }
+  constructor() {
+    _define_property(this, "customContainer", void 0);
+    _define_property(this, "cacheOption", void 0);
+    _define_property(this, "cacheManger", void 0);
+  }
+}
+const ssrCache = new ServerCache();
+export {
+  ssrCache
+};