@modern-js/prod-server 2.8.0 → 2.9.1-alpha.0

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

@@ -0,0 +1,554 @@
+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;
+};
+var __objRest = (source, exclude) => {
+  var target = {};
+  for (var prop in source)
+    if (__hasOwnProp.call(source, prop) && exclude.indexOf(prop) < 0)
+      target[prop] = source[prop];
+  if (source != null && __getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(source)) {
+      if (exclude.indexOf(prop) < 0 && __propIsEnum.call(source, prop))
+        target[prop] = source[prop];
+    }
+  return target;
+};
+var __async = (__this, __arguments, generator) => {
+  return new Promise((resolve, reject) => {
+    var fulfilled = (value) => {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var rejected = (value) => {
+      try {
+        step(generator.throw(value));
+      } catch (e) {
+        reject(e);
+      }
+    };
+    var step = (x) => x.done ? resolve(x.value) : Promise.resolve(x.value).then(fulfilled, rejected);
+    step((generator = generator.apply(__this, __arguments)).next());
+  });
+};
+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;
+  }
+  onInit(runner, app) {
+    return __async(this, null, function* () {
+      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();
+      yield this.prepareFrameHandler();
+      yield 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
+      });
+      yield this.setupBeforeProdMiddleware();
+      this.addHandler(this.staticFileHandler);
+      this.addHandler(faviconFallbackHandler);
+      this.addBeforeRouteHandler();
+      this.addHandler(this.routeHandler.bind(this));
+      this.compose();
+    });
+  }
+  onRepack(_) {
+  }
+  addBeforeRouteHandler() {
+    this.addHandler((context, next) => __async(this, null, function* () {
+      if (this.beforeRouteHandler) {
+        yield 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);
+  }
+  render(req, res, url) {
+    return __async(this, null, function* () {
+      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 = yield this.handleWeb(context, route);
+      if (!result) {
+        return null;
+      }
+      return result.content.toString();
+    });
+  }
+  createHTTPServer(handler) {
+    return __async(this, null, function* () {
+      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);
+  }
+  prepareBeforeRouteHandler(specs, distDir) {
+    return __async(this, null, function* () {
+      const { runner } = this;
+      const handler = yield runner.preparebeforeRouteHandler(
+        {
+          serverRoutes: specs,
+          distDir
+        },
+        {
+          onLast: () => null
+        }
+      );
+      this.beforeRouteHandler = handler;
+    });
+  }
+  prepareFrameHandler(options) {
+    return __async(this, null, function* () {
+      const { workDir, runner } = this;
+      const { onlyApi, onlyWeb } = options || {};
+      const _a = createMiddlewareCollecter(), { getMiddlewares } = _a, collector = __objRest(_a, ["getMiddlewares"]);
+      yield runner.gather(collector);
+      const { api: pluginAPIExt, web: pluginWebExt } = getMiddlewares();
+      const apiDir = path.join(workDir, API_DIR);
+      const serverDir = path.join(workDir, SERVER_DIR);
+      if ((yield fs.pathExists(path.join(serverDir))) && !onlyApi) {
+        const webExtension = mergeExtension(pluginWebExt);
+        this.frameWebHandler = yield this.prepareWebHandler(webExtension);
+      }
+      if (fs.existsSync(apiDir) && !onlyWeb) {
+        const apiExtension = mergeExtension(pluginAPIExt);
+        this.frameAPIHandler = yield this.prepareAPIHandler(apiExtension);
+      }
+    });
+  }
+  prepareWebHandler(extension) {
+    return __async(this, null, function* () {
+      const { workDir, runner } = this;
+      const handler = yield runner.prepareWebServer(
+        {
+          pwd: workDir,
+          config: extension
+        },
+        { onLast: () => null }
+      );
+      return handler;
+    });
+  }
+  prepareAPIHandler(extension) {
+    return __async(this, null, function* () {
+      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;
+  }
+  setupBeforeProdMiddleware() {
+    return __async(this, null, function* () {
+      const { conf, runner } = this;
+      const preMiddleware = yield runner.beforeProdServer(conf);
+      preMiddleware.flat().forEach((mid) => {
+        this.addHandler(mid);
+      });
+    });
+  }
+  handleAPI(context) {
+    return __async(this, null, function* () {
+      const { req, res } = context;
+      if (!this.frameAPIHandler) {
+        throw new Error("can not found api handler");
+      }
+      yield this.frameAPIHandler(req, res);
+    });
+  }
+  handleWeb(context, route) {
+    return __async(this, null, function* () {
+      return this.routeRenderHandler({
+        ctx: context,
+        route,
+        runner: this.runner
+      });
+    });
+  }
+  proxy() {
+    return __async(this, null, function* () {
+      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);
+  }
+  routeHandler(context) {
+    return __async(this, null, function* () {
+      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) {
+        yield this.handleAPI(context);
+        return;
+      }
+      const afterMatchContext = createAfterMatchContext(context, route.entryName);
+      if (this.runMode === RUN_MODE.FULL) {
+        yield 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);
+        yield this.frameWebHandler(middlewareContext);
+        res.locals = __spreadValues(__spreadValues({}, 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 = yield 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) {
+          yield 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);
+  }
+  renderErrorPage(context, status) {
+    return __async(this, null, function* () {
+      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 = yield 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/utils.js

@@ -0,0 +1,136 @@
+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) => {
+  const output = [];
+  return { middleware: output.concat(users) };
+};
+const noop = () => {
+};
+const createErrorDocument = (status, text) => {
+  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>
+  `;
+};
+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
+  };
+};
+const useLocalPrefix = (url) => {
+  return isProd() && !url.includes(".");
+};
+const getStaticReg = (output = {}, html = {}) => {
+  const {
+    distPath: { css: cssPath, js: jsPath, media: mediaPath } = {},
+    assetPrefix = "/"
+  } = output;
+  const { favicon, faviconByEntries } = html;
+  const prefix = useLocalPrefix(assetPrefix) ? assetPrefix : "";
+  const favicons = prepareFavicons(favicon, faviconByEntries);
+  const staticFiles = [cssPath, jsPath, mediaPath].filter((v) => Boolean(v));
+  const staticReg = ["static/", "upload/", ...staticFiles];
+  const iconReg = ["favicon.ico", "icon.png", ...favicons];
+  const regPrefix = prefix.endsWith("/") ? prefix : `${prefix}/`;
+  const staticPathRegExp = new RegExp(
+    `^${regPrefix}(${[...staticReg, ...iconReg].join("|")})`
+  );
+  return staticPathRegExp;
+};
+const prepareFavicons = (favicon, faviconByEntries) => {
+  const faviconNames = [];
+  if (favicon) {
+    faviconNames.push(favicon.substring(favicon.lastIndexOf("/") + 1));
+  }
+  if (faviconByEntries) {
+    Object.keys(faviconByEntries).forEach((f) => {
+      const curFavicon = faviconByEntries[f];
+      if (curFavicon) {
+        faviconNames.push(
+          curFavicon.substring(curFavicon.lastIndexOf("/") + 1)
+        );
+      }
+    });
+  }
+  return faviconNames;
+};
+const headersWithoutCookie = (headers) => {
+  if (typeof headers.cookie !== "undefined") {
+    const safeHeaders = __spreadValues({}, headers);
+    delete safeHeaders.cookie;
+    return safeHeaders;
+  }
+  return headers;
+};
+const isRedirect = (code) => {
+  return [301, 302, 307, 308].includes(code);
+};
+export {
+  createErrorDocument,
+  createMiddlewareCollecter,
+  debug,
+  getStaticReg,
+  headersWithoutCookie,
+  isRedirect,
+  mergeExtension,
+  noop,
+  prepareFavicons,
+  useLocalPrefix
+};