@modern-js/server-core 2.48.3-alpha.0 → 2.48.4

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

@@ -1,99 +0,0 @@
-import { REPLACE_REG } from "../../../base/constants";
-import { createErrorHtml, sortRoutes, cutNameByHyphen, 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 }) => {
-    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);
-    const renderOptions = {
-      pwd,
-      html,
-      routeInfo,
-      staticGenerate: staticGenerate || false,
-      metaName: metaName || "modern-js",
-      nonce,
-      logger,
-      nodeReq,
-      reporter,
-      serverRoutes: routes,
-      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) {
-  const query = parseQuery(req);
-  if (isSSR) {
-    if (query.__loader) {
-      return "data";
-    }
-    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"
-    })
-  });
-}
-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
-};

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

@@ -1,134 +0,0 @@
-import { SERVER_RENDER_FUNCTION_NAME, MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-import * as isbot from "isbot";
-import { getRuntimeEnv, parseHeaders, parseQuery, getHost } from "../../utils";
-import { X_RENDER_CACHE } from "../../constants";
-import { ServerTiming } from "./serverTiming";
-const defaultReporter = {
-  init() {
-  },
-  reportError() {
-  },
-  reportTiming() {
-  },
-  reportInfo() {
-  },
-  reportWarn() {
-  }
-};
-async function ssrRender(request, { routeInfo, html, staticGenerate, nonce, metaName, reporter, logger, nodeReq, serverManifest }) {
-  var _serverManifest_renderBundles;
-  const { entryName } = routeInfo;
-  const loadableStats = serverManifest.loadableStats || {};
-  const routeManifest = serverManifest.routeManifest || {};
-  const host = getHost(request);
-  const isSpider = isbot.default(request.headers.get("user-agent"));
-  const responseProxy = new ResponseProxy();
-  const query = parseQuery(request);
-  const headers = parseHeaders(request);
-  const ssrContext = {
-    request: {
-      baseUrl: routeInfo.urlPath,
-      params: {},
-      // eslint-disable-next-line node/no-unsupported-features/node-builtins, node/prefer-global/url
-      pathname: new URL(request.url).pathname,
-      host,
-      query,
-      url: request.url,
-      headers
-    },
-    response: {
-      setHeader(key, value) {
-        responseProxy.headers.set(key, value);
-      },
-      status(code) {
-        responseProxy.status = code;
-      }
-    },
-    redirection: {},
-    template: html,
-    loadableStats,
-    routeManifest,
-    entryName,
-    staticGenerate,
-    logger,
-    serverTiming: new ServerTiming(responseProxy.headers, metaName),
-    reporter: reporter || defaultReporter,
-    /** @deprecated node req */
-    req: nodeReq,
-    /** @deprecated node res  */
-    res: void 0,
-    isSpider,
-    nonce
-  };
-  const renderBundle = (_serverManifest_renderBundles = serverManifest.renderBundles) === null || _serverManifest_renderBundles === void 0 ? void 0 : _serverManifest_renderBundles[entryName || MAIN_ENTRY_NAME];
-  if (!renderBundle) {
-    throw new Error(`Can't found renderBundle ${entryName || MAIN_ENTRY_NAME}`);
-  }
-  const runtimeEnv = getRuntimeEnv();
-  let ssrResult;
-  let cacheStatus;
-  const render = renderBundle[SERVER_RENDER_FUNCTION_NAME];
-  if (runtimeEnv === "node") {
-    const cacheModuleName = "./ssrCache";
-    const { ssrCache } = await import(cacheModuleName);
-    const incomingMessage = nodeReq ? nodeReq : new IncomingMessgeProxy(request);
-    const cacheControl = await ssrCache.matchCacheControl(incomingMessage);
-    if (cacheControl) {
-      const { data: data2, status } = await ssrCache.getCache(request, cacheControl, render, ssrContext);
-      ssrResult = data2;
-      cacheStatus = status;
-    } else {
-      ssrResult = await render(ssrContext);
-    }
-  } else {
-    ssrResult = await render(ssrContext);
-  }
-  const { redirection } = ssrContext;
-  if (cacheStatus) {
-    responseProxy.headers.set(X_RENDER_CACHE, cacheStatus);
-  }
-  if (redirection.url) {
-    const { headers: headers2 } = responseProxy;
-    headers2.set("Location", redirection.url);
-    return new Response(null, {
-      status: redirection.status || 302,
-      headers: {
-        Location: redirection.url
-      }
-    });
-  }
-  const { Readable } = await import("stream").catch((_) => ({
-    Readable: void 0
-  }));
-  const streamModule = "../../adapters/node/polyfills/stream";
-  const { createReadableStreamFromReadable } = runtimeEnv === "node" ? await import(streamModule).catch((_) => ({
-    createReadableStreamFromReadable: void 0
-  })) : {
-    createReadableStreamFromReadable: void 0
-  };
-  const data = Readable && ssrResult instanceof Readable ? (createReadableStreamFromReadable === null || createReadableStreamFromReadable === void 0 ? void 0 : createReadableStreamFromReadable(ssrResult)) || "" : ssrResult;
-  return new Response(data, {
-    status: responseProxy.status,
-    headers: responseProxy.headers
-  });
-}
-class ResponseProxy {
-  constructor() {
-    this.headers = new Headers();
-    this.status = 200;
-    this.headers.set("content-type", "text/html; charset=UTF-8");
-  }
-}
-class IncomingMessgeProxy {
-  constructor(req) {
-    this.headers = {};
-    req.headers.forEach((value, key) => {
-      this.headers[key] = value;
-    });
-    this.method = req.method;
-    this.url = new URL(req.url).pathname;
-  }
-}
-export {
-  ssrRender
-};

package/dist/esm-node/base/serverBase.js

@@ -1,168 +0,0 @@
-import { INTERNAL_SERVER_PLUGINS } from "@modern-js/utils/universal/constants";
-import { Hono } from "hono";
-import { AppContext, ConfigContext, serverManager, createPlugin } from "../core";
-import { getRuntimeEnv } from "./utils";
-class ServerBase {
-  /**
-  * 初始化顺序
-  * - 获取 server runtime config
-  * - 设置 context
-  * - 创建 hooksRunner
-  * - 合并插件，内置插件和 serverConfig 中配置的插件
-  * - 执行 config hook
-  * - 获取最终的配置
-  * - 设置配置到 context
-  * - 执行 prepare hook
-  */
-  async init() {
-    const { options } = this;
-    const runtimeEnv = getRuntimeEnv();
-    runtimeEnv === "node" && await this.initServerConfig(options);
-    await this.injectContext(options);
-    this.runner = await this.createHookRunner();
-    runtimeEnv === "node" && await this.initConfig(this.runner, options);
-    await this.injectContext(options);
-    await this.runner.prepare();
-    return this;
-  }
-  async createHookRunner() {
-    serverManager.clear();
-    const runtimeEnv = getRuntimeEnv();
-    const internalPlugins = runtimeEnv === "node" ? await this.loadInternalPlugins() : [];
-    const externalPlugins = this.loadExternalPlugins();
-    const loadedPlugins = [
-      ...internalPlugins,
-      ...externalPlugins
-    ];
-    loadedPlugins.forEach((p) => {
-      serverManager.usePlugin(p);
-    });
-    const hooksRunner = await serverManager.init();
-    return hooksRunner;
-  }
-  async loadInternalPlugins() {
-    const { internalPlugins: plugins = INTERNAL_SERVER_PLUGINS, appContext, pwd } = this.options;
-    const loadPluginsModule = "../core/loadPlugins";
-    const { loadPlugins } = await import(loadPluginsModule);
-    const internalPlugins = loadPlugins(appContext.appDirectory || pwd, plugins);
-    return internalPlugins;
-  }
-  loadExternalPlugins() {
-    const { plugins = [] } = this.options;
-    const configPlugins = this.serverConfig.plugins || [];
-    const externalPlugins = [
-      ...plugins,
-      ...configPlugins
-    ];
-    return externalPlugins.map((plugin) => createPlugin(plugin.setup, plugin));
-  }
-  async initServerConfig(options) {
-    const { pwd, serverConfigFile } = options;
-    const utilsModuleName = "./utils/serverConfig";
-    const { getServerConfigPath, requireConfig } = await import(utilsModuleName);
-    const serverConfigPath = await getServerConfigPath(pwd, serverConfigFile);
-    const serverConfig = requireConfig(serverConfigPath);
-    this.serverConfig = serverConfig;
-  }
-  async injectContext(options) {
-    const appContext = await this.initAppContext();
-    const { config, pwd } = options;
-    ConfigContext.set(config);
-    AppContext.set({
-      ...appContext,
-      serverBase: this,
-      distDirectory: pwd
-    });
-  }
-  async initAppContext() {
-    const { options } = this;
-    const { pwd, plugins = [], appContext } = options;
-    const serverPlugins = plugins.map((p) => ({
-      server: p
-    }));
-    return {
-      appDirectory: (appContext === null || appContext === void 0 ? void 0 : appContext.appDirectory) || "",
-      apiDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.apiDirectory,
-      lambdaDirectory: appContext === null || appContext === void 0 ? void 0 : appContext.lambdaDirectory,
-      sharedDirectory: appContext.sharedDirectory || "",
-      distDirectory: pwd,
-      plugins: serverPlugins
-    };
-  }
-  /**
-  * Execute config hooks
-  * @param runner
-  * @param options
-  */
-  runConfigHook(runner, serverConfig) {
-    const newServerConfig = runner.config(serverConfig || {});
-    return newServerConfig;
-  }
-  async initConfig(runner, options) {
-    const path = await import("path").catch((_) => {
-      return {};
-    });
-    const utilsModuleName = "@modern-js/utils";
-    const { ensureAbsolutePath, OUTPUT_CONFIG_FILE } = await import(utilsModuleName);
-    const configModuleName = "./utils/serverConfig";
-    const { loadConfig } = await import(configModuleName);
-    const { pwd, config } = options;
-    const { serverConfig } = this;
-    const finalServerConfig = this.runConfigHook(runner, serverConfig);
-    const resolvedConfigPath = ensureAbsolutePath(pwd, path.join(config.output.path || "dist", OUTPUT_CONFIG_FILE));
-    options.config = loadConfig({
-      cliConfig: config,
-      serverConfig: finalServerConfig,
-      resolvedConfigPath
-    });
-  }
-  get all() {
-    return this.app.all;
-  }
-  get use() {
-    return this.app.use;
-  }
-  get get() {
-    return this.app.get;
-  }
-  get post() {
-    return this.app.post;
-  }
-  get put() {
-    return this.app.put;
-  }
-  get delete() {
-    return this.app.delete;
-  }
-  get patch() {
-    return this.app.patch;
-  }
-  get handle() {
-    return this.app.fetch;
-  }
-  get request() {
-    return this.app.request;
-  }
-  get notFound() {
-    return this.app.notFound;
-  }
-  get onError() {
-    return this.app.onError;
-  }
-  constructor(options) {
-    this.serverConfig = {};
-    this.options = options;
-    this.app = new Hono();
-  }
-}
-function createServerBase(options) {
-  if (options == null) {
-    throw new Error("can not start server without options");
-  }
-  const server = new ServerBase(options);
-  return server;
-}
-export {
-  ServerBase,
-  createServerBase
-};

package/dist/esm-node/base/utils/debug.js

@@ -1,5 +0,0 @@
-import { createDebugger } from "@modern-js/utils";
-const debug = createDebugger("prod-server");
-export {
-  debug
-};

package/dist/esm-node/base/utils/entry.js

@@ -1,6 +0,0 @@
-const sortRoutes = (route1, route2) => {
-  return route2.urlPath.length - route1.urlPath.length;
-};
-export {
-  sortRoutes
-};

package/dist/esm-node/base/utils/env.js

@@ -1,20 +0,0 @@
-const getRuntimeEnv = () => {
-  var _globalThis_process_release, _globalThis_process, _globalThis;
-  if (((_globalThis = globalThis) === null || _globalThis === void 0 ? void 0 : (_globalThis_process = _globalThis.process) === null || _globalThis_process === void 0 ? void 0 : (_globalThis_process_release = _globalThis_process.release) === null || _globalThis_process_release === void 0 ? void 0 : _globalThis_process_release.name) === "node") {
-    return "node";
-  }
-  return "other";
-};
-const checkIsProd = () => {
-  const env = getRuntimeEnv();
-  switch (env) {
-    case "node":
-      return process.env.NODE_ENV === "production";
-    default:
-      return false;
-  }
-};
-export {
-  checkIsProd,
-  getRuntimeEnv
-};

package/dist/esm-node/base/utils/error.js

@@ -1,41 +0,0 @@
-const ERROR_PAGE_TEXT = {
-  404: "This page could not be found.",
-  500: "Internal Server Error."
-};
-const createErrorHtml = (status) => {
-  const text = ERROR_PAGE_TEXT[status] || "";
-  const title = `${status}: ${text}`;
-  return `<!DOCTYPE html>
-  <html lang="en">
-  <head>
-    <meta charset="utf-8">
-    <meta name="viewport" content="width=device-width">
-    <title>${title}</title>
-    <style>
-      html,body {
-        margin: 0;
-      }
-
-      .page-container {
-        color: #000;
-        background: #fff;
-        height: 100vh;
-        text-align: center;
-        display: flex;
-        flex-direction: column;
-        align-items: center;
-        justify-content: center;
-      }
-    </style>
-  </head>
-  <body>
-    <div class="page-container">
-    <h1>${status}</h1>
-    <div>${text}</div>
-  </body>
-  </html>
-  `;
-};
-export {
-  createErrorHtml
-};

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

@@ -1,13 +0,0 @@
-export * from "./env";
-export * from "./request";
-export * from "./transformStream";
-export * from "./middlewareCollector";
-export * from "./error";
-export * from "./warmup";
-export * from "./entry";
-const cutNameByHyphen = (s) => {
-  return s.split(/[-_]/)[0];
-};
-export {
-  cutNameByHyphen
-};

package/dist/esm-node/base/utils/middlewareCollector.js

@@ -1,29 +0,0 @@
-const mergeExtension = (users) => {
-  const output = [];
-  return {
-    middleware: output.concat(users)
-  };
-};
-const createMiddlewareCollecter = () => {
-  const webMiddlewares = [];
-  const apiMiddlewares = [];
-  const addWebMiddleware = (input) => {
-    webMiddlewares.push(input);
-  };
-  const addAPIMiddleware = (input) => {
-    apiMiddlewares.push(input);
-  };
-  const getMiddlewares = () => ({
-    web: webMiddlewares,
-    api: apiMiddlewares
-  });
-  return {
-    getMiddlewares,
-    addWebMiddleware,
-    addAPIMiddleware
-  };
-};
-export {
-  createMiddlewareCollecter,
-  mergeExtension
-};