@modern-js/prod-server 2.4.1-beta.0 → 2.5.0

package/dist/esm-node/server/index.js

@@ -0,0 +1,156 @@
+import path from "path";
+import fs from "fs";
+import {
+  Logger,
+  SHARED_DIR,
+  OUTPUT_CONFIG_FILE,
+  dotenv,
+  dotenvExpand,
+  INTERNAL_SERVER_PLUGINS
+} from "@modern-js/utils";
+import {
+  serverManager,
+  AppContext,
+  ConfigContext,
+  loadPlugins
+} from "@modern-js/server-core";
+import { metrics as defaultMetrics } from "../libs/metrics";
+import {
+  loadConfig,
+  getServerConfigPath,
+  requireConfig
+} from "../libs/loadConfig";
+import { debug } from "../utils";
+import { createProdServer } from "./modern-server-split";
+class Server {
+  constructor(options) {
+    this.serverImpl = createProdServer;
+    options.logger = options.logger || new Logger({
+      level: "warn"
+    });
+    options.metrics = options.metrics || defaultMetrics;
+    this.options = options;
+    this.serverConfig = {};
+  }
+  async init() {
+    const { options } = this;
+    this.loadServerEnv(options);
+    this.initServerConfig(options);
+    await this.injectContext(this.runner, options);
+    this.runner = await this.createHookRunner();
+    await this.initConfig(this.runner, options);
+    await this.injectContext(this.runner, options);
+    this.server = this.serverImpl(options);
+    await this.runPrepareHook(this.runner);
+    this.app = await this.server.createHTTPServer(this.getRequestHandler());
+    await this.server.onInit(this.runner, this.app);
+    return this;
+  }
+  runConfigHook(runner, serverConfig) {
+    const newServerConfig = runner.config(serverConfig || {});
+    return newServerConfig;
+  }
+  async runPrepareHook(runner) {
+    runner.prepare();
+  }
+  initServerConfig(options) {
+    const { pwd, serverConfigFile } = options;
+    const distDirectory = path.join(pwd, options.config.output.path || "dist");
+    const serverConfigPath = getServerConfigPath(
+      distDirectory,
+      serverConfigFile
+    );
+    const serverConfig = requireConfig(serverConfigPath);
+    this.serverConfig = serverConfig;
+  }
+  async initConfig(runner, options) {
+    const { pwd, config } = options;
+    const { serverConfig } = this;
+    const finalServerConfig = this.runConfigHook(runner, serverConfig);
+    const resolvedConfigPath = path.join(
+      pwd,
+      config.output.path || "dist",
+      OUTPUT_CONFIG_FILE
+    );
+    options.config = loadConfig({
+      cliConfig: config,
+      serverConfig: finalServerConfig,
+      resolvedConfigPath
+    });
+  }
+  async close() {
+    this.app.close();
+  }
+  listen(options, listener) {
+    const callback = () => {
+      listener == null ? void 0 : listener();
+    };
+    if (typeof options === "object") {
+      this.app.listen(options, callback);
+    } else {
+      this.app.listen(process.env.PORT || options || 8080, callback);
+    }
+  }
+  getRequestHandler() {
+    return (req, res, next) => {
+      const requestHandler = this.server.getRequestHandler();
+      return requestHandler(req, res, next);
+    };
+  }
+  async render(req, res, url) {
+    return this.server.render(req, res, url);
+  }
+  async createHookRunner() {
+    serverManager.clear();
+    const { options } = this;
+    const {
+      internalPlugins = INTERNAL_SERVER_PLUGINS,
+      pwd,
+      plugins = []
+    } = options;
+    const serverPlugins = this.serverConfig.plugins || [];
+    const loadedPlugins = loadPlugins(pwd, [...serverPlugins, ...plugins], {
+      internalPlugins
+    });
+    debug("plugins", loadedPlugins);
+    loadedPlugins.forEach((p) => {
+      serverManager.usePlugin(p);
+    });
+    const hooksRunner = await serverManager.init();
+    return hooksRunner;
+  }
+  async injectContext(runner, options) {
+    const appContext = this.initAppContext();
+    const { config, pwd } = options;
+    ConfigContext.set(config);
+    AppContext.set({
+      ...appContext,
+      distDirectory: path.join(pwd, config.output.path || "dist")
+    });
+  }
+  initAppContext() {
+    const { options } = this;
+    const { pwd: appDirectory, plugins = [], config } = options;
+    const serverPlugins = plugins.map((p) => ({
+      server: p
+    }));
+    return {
+      appDirectory,
+      distDirectory: path.join(appDirectory, config.output.path || "dist"),
+      sharedDirectory: path.resolve(appDirectory, SHARED_DIR),
+      plugins: serverPlugins
+    };
+  }
+  loadServerEnv(options) {
+    const { pwd: appDirectory } = options;
+    const serverEnv = process.env.MODERN_ENV;
+    const serverEnvPath = path.resolve(appDirectory, `.env.${serverEnv}`);
+    if (serverEnv && fs.existsSync(serverEnvPath) && !fs.statSync(serverEnvPath).isDirectory()) {
+      const envConfig = dotenv.config({ path: serverEnvPath });
+      dotenvExpand(envConfig);
+    }
+  }
+}
+export {
+  Server
+};

package/dist/esm-node/server/modern-server-split.js

@@ -0,0 +1,43 @@
+import { ModernServer } from "./modern-server";
+class ModernSSRServer extends ModernServer {
+  prepareAPIHandler(_) {
+    return null;
+  }
+  async handleAPI(context) {
+    return this.render404(context);
+  }
+}
+class ModernAPIServer extends ModernServer {
+  prepareWebHandler(_) {
+    return null;
+  }
+  filterRoutes(routes) {
+    return routes.filter((route) => route.isApi);
+  }
+}
+class ModernWebServer extends ModernServer {
+  async warmupSSRBundle() {
+    return null;
+  }
+  async handleAPI(context) {
+    return this.render404(context);
+  }
+  async handleWeb(context, route) {
+    route.isSSR = false;
+    return super.handleWeb(context, route);
+  }
+}
+const createProdServer = (options) => {
+  if (options.apiOnly) {
+    return new ModernAPIServer(options);
+  } else if (options.ssrOnly) {
+    return new ModernSSRServer(options);
+  } else if (options.webOnly) {
+    return new ModernWebServer(options);
+  } else {
+    return new ModernServer(options);
+  }
+};
+export {
+  createProdServer
+};

package/dist/esm-node/server/modern-server.js

@@ -0,0 +1,483 @@
+import { createServer } from "http";
+import path from "path";
+import { fs, isPromise, mime, ROUTE_SPEC_FILE } from "@modern-js/utils";
+import {
+  RouteMatchManager
+} from "../libs/route";
+import { createRenderHandler } from "../libs/render";
+import {
+  createStaticFileHandler,
+  faviconFallbackHandler
+} from "../libs/serve-file";
+import {
+  createErrorDocument,
+  createMiddlewareCollecter,
+  getStaticReg,
+  mergeExtension,
+  noop,
+  debug,
+  isRedirect
+} from "../utils";
+import * as reader from "../libs/render/reader";
+import { createProxyHandler } from "../libs/proxy";
+import { createContext } from "../libs/context";
+import { templateInjectableStream } from "../libs/hook-api/template";
+import {
+  AGGRED_DIR,
+  ERROR_DIGEST,
+  ERROR_PAGE_TEXT,
+  RUN_MODE
+} from "../constants";
+import {
+  createAfterMatchContext,
+  createAfterRenderContext,
+  createMiddlewareContext
+} from "../libs/hook-api";
+const API_DIR = "./api";
+const SERVER_DIR = "./server";
+class ModernServer {
+  constructor({
+    pwd,
+    config,
+    routes,
+    staticGenerate,
+    logger,
+    metrics,
+    runMode,
+    proxyTarget
+  }) {
+    this.handlers = [];
+    this.reader = reader;
+    this.beforeRouteHandler = null;
+    this.frameWebHandler = null;
+    this.frameAPIHandler = null;
+    this.proxyHandler = null;
+    require("ignore-styles");
+    this.pwd = pwd;
+    this.distDir = path.join(pwd, config.output.path || "dist");
+    this.workDir = this.distDir;
+    this.conf = config;
+    debug("server conf", this.conf);
+    this.logger = logger;
+    this.metrics = metrics;
+    this.router = new RouteMatchManager();
+    this.presetRoutes = routes;
+    this.proxyTarget = proxyTarget;
+    this.staticGenerate = staticGenerate || false;
+    this.runMode = runMode || RUN_MODE.FULL;
+  }
+  async onInit(runner, app) {
+    var _a, _b;
+    this.runner = runner;
+    const { distDir, staticGenerate, conf } = this;
+    debug("final server conf", this.conf);
+    this.proxyHandler = createProxyHandler((_a = conf.bff) == null ? void 0 : _a.proxy);
+    if (this.proxyHandler) {
+      this.proxyHandler.forEach((handler) => {
+        this.addHandler(handler);
+      });
+    }
+    this.reader.init();
+    app.on("close", () => {
+      this.reader.close();
+    });
+    const usageRoutes = this.filterRoutes(this.getRoutes());
+    this.router.reset(usageRoutes);
+    this.warmupSSRBundle();
+    await this.prepareFrameHandler();
+    await this.prepareBeforeRouteHandler(usageRoutes, distDir);
+    const staticPathRegExp = getStaticReg(
+      this.conf.output || {},
+      this.conf.html
+    );
+    this.staticFileHandler = createStaticFileHandler(
+      [
+        {
+          path: staticPathRegExp,
+          target: distDir
+        }
+      ],
+      this.conf.output
+    );
+    const ssrConfig = (_b = this.conf.server) == null ? void 0 : _b.ssr;
+    const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
+    this.routeRenderHandler = createRenderHandler({
+      distDir,
+      staticGenerate,
+      forceCSR
+    });
+    await this.setupBeforeProdMiddleware();
+    this.addHandler(this.staticFileHandler);
+    this.addHandler(faviconFallbackHandler);
+    this.addBeforeRouteHandler();
+    this.addHandler(this.routeHandler.bind(this));
+    this.compose();
+  }
+  onRepack(_) {
+  }
+  addBeforeRouteHandler() {
+    this.addHandler(async (context, next) => {
+      if (this.beforeRouteHandler) {
+        await this.beforeRouteHandler(context);
+        if (this.isSend(context.res)) {
+          return;
+        }
+      }
+      return next();
+    });
+  }
+  onServerChange({ filepath }) {
+    const { pwd } = this;
+    const { api, server } = AGGRED_DIR;
+    const apiPath = path.normalize(path.join(pwd, api));
+    const serverPath = path.normalize(path.join(pwd, server));
+    const onlyApi = filepath.startsWith(apiPath);
+    const onlyWeb = filepath.startsWith(serverPath);
+    this.prepareFrameHandler({ onlyWeb, onlyApi });
+  }
+  getRequestHandler() {
+    return this.requestHandler.bind(this);
+  }
+  async render(req, res, url) {
+    req.logger = req.logger || this.logger;
+    req.metrics = req.metrics || this.metrics;
+    const context = createContext(req, res);
+    const matched = this.router.match(url || context.path);
+    if (!matched) {
+      return null;
+    }
+    const route = matched.generate(context.url);
+    const result = await this.handleWeb(context, route);
+    if (!result) {
+      return null;
+    }
+    return result.content.toString();
+  }
+  async createHTTPServer(handler) {
+    return createServer(handler);
+  }
+  getRoutes() {
+    if (this.presetRoutes) {
+      return this.presetRoutes;
+    }
+    const file = path.join(this.distDir, ROUTE_SPEC_FILE);
+    if (fs.existsSync(file)) {
+      const content = fs.readJSONSync(file);
+      return content.routes;
+    }
+    return [];
+  }
+  addHandler(handler) {
+    this.handlers.push(handler);
+  }
+  render404(context) {
+    context.error(ERROR_DIGEST.ENOTF, "404 Not Found");
+    this.renderErrorPage(context, 404);
+  }
+  async prepareBeforeRouteHandler(specs, distDir) {
+    const { runner } = this;
+    const handler = await runner.preparebeforeRouteHandler(
+      {
+        serverRoutes: specs,
+        distDir
+      },
+      {
+        onLast: () => null
+      }
+    );
+    this.beforeRouteHandler = handler;
+  }
+  async prepareFrameHandler(options) {
+    const { workDir, runner } = this;
+    const { onlyApi, onlyWeb } = options || {};
+    const { getMiddlewares, ...collector } = createMiddlewareCollecter();
+    await runner.gather(collector);
+    const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
+    const apiDir = path.join(workDir, API_DIR);
+    const serverDir = path.join(workDir, SERVER_DIR);
+    if (await fs.pathExists(path.join(serverDir)) && !onlyApi) {
+      const webExtension = mergeExtension(pluginWebExt);
+      this.frameWebHandler = await this.prepareWebHandler(webExtension);
+    }
+    if (fs.existsSync(apiDir) && !onlyWeb) {
+      const apiExtension = mergeExtension(pluginAPIExt);
+      this.frameAPIHandler = await this.prepareAPIHandler(apiExtension);
+    }
+  }
+  async prepareWebHandler(extension) {
+    const { workDir, runner } = this;
+    const handler = await runner.prepareWebServer(
+      {
+        pwd: workDir,
+        config: extension
+      },
+      { onLast: () => null }
+    );
+    return handler;
+  }
+  async prepareAPIHandler(extension) {
+    const { workDir, runner, conf } = this;
+    const { bff } = conf;
+    const prefix = (bff == null ? void 0 : bff.prefix) || "/api";
+    return runner.prepareApiServer(
+      {
+        pwd: workDir,
+        config: extension,
+        prefix: Array.isArray(prefix) ? prefix[0] : prefix,
+        render: this.render.bind(this)
+      },
+      { onLast: () => null }
+    );
+  }
+  filterRoutes(routes) {
+    return routes;
+  }
+  async setupBeforeProdMiddleware() {
+    const { conf, runner } = this;
+    const preMiddleware = await runner.beforeProdServer(conf);
+    preMiddleware.flat().forEach((mid) => {
+      this.addHandler(mid);
+    });
+  }
+  async handleAPI(context) {
+    const { req, res } = context;
+    if (!this.frameAPIHandler) {
+      throw new Error("can not found api handler");
+    }
+    await this.frameAPIHandler(req, res);
+  }
+  async handleWeb(context, route) {
+    return this.routeRenderHandler({
+      ctx: context,
+      route,
+      runner: this.runner
+    });
+  }
+  async proxy() {
+    return null;
+  }
+  warmupSSRBundle() {
+    const { distDir } = this;
+    const bundles = this.router.getBundles();
+    bundles.forEach((bundle) => {
+      const filepath = path.join(distDir, bundle);
+      if (fs.existsSync(filepath)) {
+        require(filepath);
+      }
+    });
+  }
+  createContext(req, res, options = {}) {
+    return createContext(req, res, options);
+  }
+  async routeHandler(context) {
+    const { res } = context;
+    const matched = this.router.match(context.path);
+    if (!matched) {
+      this.render404(context);
+      return;
+    }
+    let route = matched.generate(context.url);
+    if (route.isApi) {
+      await this.handleAPI(context);
+      return;
+    }
+    const afterMatchContext = createAfterMatchContext(context, route.entryName);
+    if (this.runMode === RUN_MODE.FULL) {
+      await this.runner.afterMatch(afterMatchContext, { onLast: noop });
+    }
+    if (this.isSend(res)) {
+      return;
+    }
+    const { current, url, status } = afterMatchContext.router;
+    if (url) {
+      this.redirect(res, url, status);
+      return;
+    }
+    if (route.entryName !== current) {
+      const matched2 = this.router.matchEntry(current);
+      if (!matched2) {
+        this.render404(context);
+        return;
+      }
+      route = matched2.generate(context.url);
+    }
+    context.setParams(route.params);
+    context.setServerData("router", {
+      baseUrl: route.urlPath,
+      params: route.params
+    });
+    if (this.frameWebHandler) {
+      res.locals = res.locals || {};
+      const middlewareContext = createMiddlewareContext(context);
+      await this.frameWebHandler(middlewareContext);
+      res.locals = {
+        ...res.locals,
+        ...middlewareContext.response.locals
+      };
+    }
+    if (this.isSend(res)) {
+      return;
+    }
+    if (route.responseHeaders) {
+      Object.keys(route.responseHeaders).forEach((key) => {
+        const value = route.responseHeaders[key];
+        if (value) {
+          context.res.setHeader(key, value);
+        }
+      });
+    }
+    const renderResult = await this.handleWeb(context, route);
+    if (!renderResult) {
+      this.render404(context);
+      return;
+    }
+    if (renderResult.redirect) {
+      this.redirect(
+        res,
+        renderResult.content,
+        renderResult.statusCode
+      );
+      return;
+    }
+    if (this.isSend(res)) {
+      return;
+    }
+    res.setHeader("content-type", renderResult.contentType);
+    const { contentStream } = renderResult;
+    if (contentStream) {
+      contentStream.pipe(
+        templateInjectableStream({
+          prependHead: route.entryName ? `<script>window._SERVER_DATA=${JSON.stringify(
+            context.serverData
+          )}<\/script>` : void 0
+        })
+      ).pipe(res);
+      return;
+    }
+    let response = renderResult.content;
+    if (route.entryName) {
+      const afterRenderContext = createAfterRenderContext(
+        context,
+        response.toString()
+      );
+      if (this.runMode === RUN_MODE.FULL) {
+        await this.runner.afterRender(afterRenderContext, { onLast: noop });
+      }
+      if (this.isSend(res)) {
+        return;
+      }
+      afterRenderContext.template.prependHead(
+        `<script>window._SERVER_DATA=${JSON.stringify(
+          context.serverData
+        )}<\/script>`
+      );
+      response = afterRenderContext.template.get();
+    }
+    res.end(response);
+  }
+  isSend(res) {
+    if (res.headersSent) {
+      return true;
+    }
+    if (res.getHeader("Location") && isRedirect(res.statusCode)) {
+      res.end();
+      return true;
+    }
+    return false;
+  }
+  compose() {
+    const { handlers } = this;
+    if (!Array.isArray(handlers)) {
+      throw new TypeError("Middleware stack must be an array!");
+    }
+    for (const fn of handlers) {
+      if (typeof fn !== "function") {
+        throw new TypeError("Middleware must be composed of functions!");
+      }
+    }
+    this._handler = (context, next) => {
+      let i = 0;
+      const dispatch = (error) => {
+        if (error) {
+          return this.onError(context, error);
+        }
+        const handler = handlers[i++];
+        if (!handler) {
+          return next();
+        }
+        try {
+          const result = handler(context, dispatch);
+          if (isPromise(result)) {
+            return result.catch(onError);
+          }
+        } catch (e) {
+          return onError(e);
+        }
+      };
+      const onError = (err) => {
+        this.onError(context, err);
+      };
+      return dispatch();
+    };
+  }
+  requestHandler(req, res, next = () => {
+  }) {
+    res.statusCode = 200;
+    req.logger = req.logger || this.logger;
+    req.metrics = req.metrics || this.metrics;
+    let context;
+    try {
+      context = this.createContext(req, res);
+    } catch (e) {
+      this.logger.error(e);
+      res.statusCode = 500;
+      res.setHeader("content-type", mime.contentType("html"));
+      return res.end(createErrorDocument(500, ERROR_PAGE_TEXT[500]));
+    }
+    try {
+      return this._handler(context, next);
+    } catch (err) {
+      return this.onError(context, err);
+    }
+  }
+  redirect(res, url, status = 302) {
+    res.setHeader("Location", url);
+    res.statusCode = status;
+    res.end();
+  }
+  onError(context, err) {
+    context.error(ERROR_DIGEST.EINTER, err);
+    this.renderErrorPage(context, 500);
+  }
+  async renderErrorPage(context, status) {
+    const { res } = context;
+    context.status = status;
+    res.setHeader("content-type", mime.contentType("html"));
+    const statusPage = `/${status}`;
+    const customErrorPage = `/_error`;
+    const matched = this.router.match(statusPage) || this.router.match(customErrorPage);
+    if (matched) {
+      const route = matched.generate(context.url);
+      const { entryName } = route;
+      if (entryName === status.toString() || entryName === "_error") {
+        try {
+          const file = await this.routeRenderHandler({
+            route,
+            ctx: context,
+            runner: this.runner
+          });
+          if (file) {
+            context.res.end(file.content);
+            return;
+          }
+        } catch (e) {
+        }
+      }
+    }
+    const text = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT[500];
+    context.res.end(createErrorDocument(status, text));
+  }
+}
+export {
+  ModernServer
+};

package/dist/{js/modern → esm-node}/utils.js

@@ -1,19 +1,3 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __propIsEnum = Object.prototype.propertyIsEnumerable;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __spreadValues = (a, b) => {
-  for (var prop in b || (b = {}))
-    if (__hasOwnProp.call(b, prop))
-      __defNormalProp(a, prop, b[prop]);
-  if (__getOwnPropSymbols)
-    for (var prop of __getOwnPropSymbols(b)) {
-      if (__propIsEnum.call(b, prop))
-        __defNormalProp(a, prop, b[prop]);
-    }
-  return a;
-};
 import { createDebugger, isProd } from "@modern-js/utils";
 const debug = createDebugger("prod-server");
 const mergeExtension = (users) => {
@@ -113,7 +97,7 @@ const prepareFavicons = (favicon, faviconByEntries) => {
 };
 const headersWithoutCookie = (headers) => {
   if (typeof headers.cookie !== "undefined") {
-    const safeHeaders = __spreadValues({}, headers);
+    const safeHeaders = { ...headers };
     delete safeHeaders.cookie;
     return safeHeaders;
   }