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

package/CHANGELOG.md

@@ -1,5 +1,50 @@
 # @modern-js/prod-server
 
+## 2.11.0
+
+### Patch Changes
+
+- 381a3b9: feat(utils): move universal utils to the universal folder
+
+  feat(utils): 将运行时使用的 utils 移动到 universal 目录
+
+- Updated dependencies [cfb058f]
+- Updated dependencies [0bd018b]
+- Updated dependencies [5d624fd]
+- Updated dependencies [e2466a1]
+- Updated dependencies [02bb383]
+- Updated dependencies [381a3b9]
+- Updated dependencies [7a60f10]
+- Updated dependencies [274b2e5]
+- Updated dependencies [b9e1c54]
+  - @modern-js/utils@2.11.0
+  - @modern-js/server-core@2.11.0
+
+## 2.10.0
+
+### Minor Changes
+
+- d8bbf28: feat: .env file should be load when prod server is started
+  feat: 在 server 启动时，.env 文件应该被加载
+
+### Patch Changes
+
+- 3e0bd50: feat: when enable bff handle render, support use `useContext` to get framework plugin context in data loader.
+  feat: 当开启 BFF 托管渲染时，支持在 data loader 中使用 `useContext` 获取框架插件提供的上下文。
+- 92d247f: fix: support tools.devServer.header include string[] type, remove get & delete & apply api in hook or middleware api
+  fix: 支持 tools.devServer.header 包含字符串数组类型，移除 Hook 和 Middleware 中对 响应 Cookie 的获取、删除操作
+- 0da32d0: chore: upgrade jest and puppeteer
+  chore: 升级 jest 和 puppeteer 到 latest
+- 0d9962b: fix: add types field in package.json
+  fix: 添加 package.json 中的 types 字段
+- Updated dependencies [3e0bd50]
+- Updated dependencies [0da32d0]
+- Updated dependencies [fbefa7e]
+- Updated dependencies [4d54233]
+- Updated dependencies [6db4864]
+  - @modern-js/server-core@2.10.0
+  - @modern-js/utils@2.10.0
+
 ## 2.9.0
 
 ### Patch Changes

package/dist/cjs/libs/hook-api/index.js

@@ -39,13 +39,9 @@ var import_template = require("./template");
 class Response {
   constructor(res) {
     this.res = res;
-    this._cookie = import_cookie.default.parse(res.getHeader("set-cookie") || "");
     this.cookies = {
-      get: this.getCookie.bind(this),
       set: this.setCookie.bind(this),
-      delete: this.deleteCookie.bind(this),
-      clear: this.clearCookie.bind(this),
-      apply: this.applyCookie.bind(this)
+      clear: this.clearCookie.bind(this)
     };
   }
   get(key) {
@@ -57,29 +53,14 @@ class Response {
   status(code) {
     this.res.statusCode = code;
   }
-  getCookie(key) {
-    return this._cookie[key];
-  }
-  setCookie(key, value) {
-    this._cookie[key] = value;
-  }
-  deleteCookie(key) {
-    if (this._cookie[key]) {
-      delete this._cookie[key];
-    }
+  setCookie(key, value, options) {
+    const cookieValue = this.res.getHeader("set-cookie");
+    const fmt = Array.isArray(cookieValue) ? cookieValue : [cookieValue].filter(Boolean);
+    fmt.push(import_cookie.default.serialize(key, value, options));
+    this.res.setHeader("set-cookie", fmt.length === 1 ? fmt[0] : fmt);
   }
   clearCookie() {
-    this._cookie = {};
-  }
-  applyCookie() {
-    const str = Object.entries(this._cookie).map(([key, value]) => {
-      return import_cookie.default.serialize(key, value);
-    }).join("; ");
-    if (str) {
-      this.res.setHeader("set-cookie", str);
-    } else {
-      this.res.removeHeader("set-cookie");
-    }
+    this.res.removeHeader("set-cookie");
   }
   raw(body, options) {
     const { status, headers = {} } = options || {};

package/dist/cjs/libs/render/index.js

@@ -36,6 +36,7 @@ var import_constants = require("../../constants");
 var import_static = require("./static");
 var import_reader = require("./reader");
 var ssr = __toESM(require("./ssr"));
+var import_utils2 = require("./utils");
 const createRenderHandler = ({
   distDir,
   staticGenerate,
@@ -87,7 +88,7 @@ const createRenderHandler = ({
     }
   }
   return {
-    content,
+    content: route.entryName ? (0, import_utils2.injectSeverData)(content.toString(), ctx) : content,
     contentType: import_utils.mime.contentType(import_path.default.extname(templatePath))
   };
 };

package/dist/cjs/libs/render/ssr.js

@@ -32,8 +32,10 @@ __export(ssr_exports, {
 module.exports = __toCommonJS(ssr_exports);
 var import_path = __toESM(require("path"));
 var import_utils = require("@modern-js/utils");
+var import_constants = require("@modern-js/utils/constants");
 var import_cache = __toESM(require("./cache"));
 var import_measure = require("./measure");
+var import_utils2 = require("./utils");
 const render = async (ctx, renderOptions, runner) => {
   var _a;
   const {
@@ -46,9 +48,9 @@ const render = async (ctx, renderOptions, runner) => {
     enableUnsafeCtx = false
   } = renderOptions;
   const bundleJS = import_path.default.join(distDir, bundle);
-  const loadableUri = import_path.default.join(distDir, import_utils.LOADABLE_STATS_FILE);
+  const loadableUri = import_path.default.join(distDir, import_constants.LOADABLE_STATS_FILE);
   const loadableStats = import_utils.fs.existsSync(loadableUri) ? require(loadableUri) : "";
-  const routesManifestUri = import_path.default.join(distDir, import_utils.ROUTE_MINIFEST_FILE);
+  const routesManifestUri = import_path.default.join(distDir, import_constants.ROUTE_MANIFEST_FILE);
   const routeManifest = import_utils.fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
   const context = {
     request: {
@@ -85,7 +87,7 @@ const render = async (ctx, renderOptions, runner) => {
   context.logger = (0, import_measure.createLogger)(context, ctx.logger);
   context.metrics = (0, import_measure.createMetrics)(context, ctx.metrics);
   runner.extendSSRContext(context);
-  const serverRender = require(bundleJS)[import_utils.SERVER_RENDER_FUNCTION_NAME];
+  const serverRender = require(bundleJS)[import_constants.SERVER_RENDER_FUNCTION_NAME];
   const content = await (0, import_cache.default)(serverRender, ctx)(context);
   const { url, status = 302 } = context.redirection;
   if (url) {
@@ -98,13 +100,13 @@ const render = async (ctx, renderOptions, runner) => {
   }
   if (typeof content === "string") {
     return {
-      content,
+      content: (0, import_utils2.injectSeverData)(content, ctx),
       contentType: import_utils.mime.contentType("html")
     };
   } else {
     return {
       content: "",
-      contentStream: content,
+      contentStream: (0, import_utils2.injectServerDataStream)(content, ctx),
       contentType: import_utils.mime.contentType("html")
     };
   }

package/dist/{js/node/libs/metrics.js → cjs/libs/render/utils.js}

@@ -15,20 +15,33 @@ var __copyProps = (to, from, except, desc) => {
   return to;
 };
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-var metrics_exports = {};
-__export(metrics_exports, {
-  metrics: () => metrics
+var utils_exports = {};
+__export(utils_exports, {
+  injectServerDataStream: () => injectServerDataStream,
+  injectSeverData: () => injectSeverData
 });
-module.exports = __toCommonJS(metrics_exports);
-const metrics = {
-  gauges() {
-  },
-  emitCounter() {
-  },
-  emitTimer() {
-  }
+module.exports = __toCommonJS(utils_exports);
+var import_template = require("../hook-api/template");
+const injectSeverData = (content, context) => {
+  const template = new import_template.TemplateAPI(content);
+  template.prependHead(
+    `<script>window._SERVER_DATA=${JSON.stringify(
+      context.serverData
+    )}</script>`
+  );
+  return template.get();
+};
+const injectServerDataStream = (content, context) => {
+  return content.pipe(
+    (0, import_template.templateInjectableStream)({
+      prependHead: `<script>window._SERVER_DATA=${JSON.stringify(
+        context.serverData
+      )}</script>`
+    })
+  );
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  metrics
+  injectServerDataStream,
+  injectSeverData
 });

package/dist/cjs/server/index.js

@@ -189,7 +189,7 @@ class Server {
     const serverEnv = process.env.MODERN_ENV;
     const defaultEnvPath = import_path.default.resolve(appDirectory, `.env`);
     const serverEnvPath = import_path.default.resolve(appDirectory, `.env.${serverEnv}`);
-    for (const envPath of [defaultEnvPath, serverEnvPath]) {
+    for (const envPath of [serverEnvPath, defaultEnvPath]) {
       if (await import_utils.fs.pathExists(envPath) && !(await import_utils.fs.stat(envPath)).isDirectory()) {
         const envConfig = import_utils.dotenv.config({ path: envPath });
         (0, import_utils.dotenvExpand)(envConfig);

package/dist/cjs/server/modernServer.js

@@ -40,7 +40,6 @@ var import_utils2 = require("../utils");
 var reader = __toESM(require("../libs/render/reader"));
 var import_proxy = require("../libs/proxy");
 var import_context = require("../libs/context");
-var import_template = require("../libs/hook-api/template");
 var import_constants = require("../constants");
 var import_hook_api = require("../libs/hook-api");
 const SERVER_DIR = "./server";
@@ -57,7 +56,7 @@ class ModernServer {
   }) {
     this.handlers = [];
     this.reader = reader;
-    this.beforeRouteHandler = null;
+    this.loaderHandler = null;
     this.frameWebHandler = null;
     this.frameAPIHandler = null;
     this.proxyHandler = null;
@@ -95,7 +94,7 @@ class ModernServer {
     this.router.reset(usageRoutes);
     this.warmupSSRBundle();
     await this.prepareFrameHandler();
-    await this.prepareBeforeRouteHandler(usageRoutes, distDir);
+    await this.prepareLoaderHandler(usageRoutes, distDir);
     const ssrConfig = (_b = this.conf.server) == null ? void 0 : _b.ssr;
     const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
     this.routeRenderHandler = (0, import_render.createRenderHandler)({
@@ -106,24 +105,12 @@ class ModernServer {
     await this.setupBeforeProdMiddleware();
     this.addHandler(this.setupStaticMiddleware((_c = this.conf.output) == null ? void 0 : _c.assetPrefix));
     this.addHandler(import_serveFile.faviconFallbackHandler);
-    this.addBeforeRouteHandler();
     this.addHandler(this.routeHandler.bind(this));
     this.compose();
   }
   // server ready
   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 } = import_constants.AGGRED_DIR;
@@ -150,6 +137,9 @@ class ModernServer {
     if (!result) {
       return null;
     }
+    if (result.contentStream) {
+      return result.contentStream;
+    }
     return result.content.toString();
   }
   async createHTTPServer(handler) {
@@ -178,9 +168,9 @@ class ModernServer {
     context.error(import_constants.ERROR_DIGEST.ENOTF, "404 Not Found");
     this.renderErrorPage(context, 404);
   }
-  async prepareBeforeRouteHandler(specs, distDir) {
+  async prepareLoaderHandler(specs, distDir) {
     const { runner } = this;
-    const handler = await runner.preparebeforeRouteHandler(
+    const handler = await runner.prepareLoaderHandler(
       {
         serverRoutes: specs,
         distDir
@@ -189,7 +179,7 @@ class ModernServer {
         onLast: () => null
       }
     );
-    this.beforeRouteHandler = handler;
+    this.loaderHandler = handler;
   }
   // gather frame extension and get framework handler
   async prepareFrameHandler(options) {
@@ -275,11 +265,48 @@ class ModernServer {
     await this.frameAPIHandler(req, res);
   }
   async handleWeb(context, route) {
-    return this.routeRenderHandler({
+    const { res } = context;
+    if (this.loaderHandler) {
+      await this.loaderHandler(context);
+      if (this.isSend(res)) {
+        return null;
+      }
+    }
+    context.setParams(route.params);
+    context.setServerData("router", {
+      baseUrl: route.urlPath,
+      params: route.params
+    });
+    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.routeRenderHandler({
       ctx: context,
       route,
       runner: this.runner
     });
+    if (!renderResult) {
+      this.render404(context);
+      return null;
+    }
+    if (renderResult.redirect) {
+      this.redirect(
+        res,
+        renderResult.content,
+        renderResult.statusCode
+      );
+      return null;
+    }
+    if (this.isSend(res)) {
+      return null;
+    }
+    res.setHeader("content-type", renderResult.contentType);
+    return renderResult;
   }
   async proxy() {
     return null;
@@ -312,31 +339,31 @@ class ModernServer {
       await this.handleAPI(context);
       return;
     }
-    const afterMatchContext = (0, import_hook_api.createAfterMatchContext)(context, route.entryName);
-    if (this.runMode === import_constants.RUN_MODE.FULL) {
-      await this.runner.afterMatch(afterMatchContext, { onLast: import_utils2.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);
+    if (route.entryName) {
+      const afterMatchContext = (0, import_hook_api.createAfterMatchContext)(
+        context,
+        route.entryName
+      );
+      if (this.runMode === import_constants.RUN_MODE.FULL) {
+        await this.runner.afterMatch(afterMatchContext, { onLast: import_utils2.noop });
+      }
+      if (this.isSend(res)) {
         return;
       }
-      route = matched2.generate(context.url);
+      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 = (0, import_hook_api.createMiddlewareContext)(context);
@@ -345,47 +372,20 @@ class ModernServer {
         ...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);
-        }
-      });
+      if (this.isSend(res)) {
+        return;
+      }
     }
     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)) {
+    const { contentStream: responseStream } = renderResult;
+    let { content: response } = renderResult;
+    if (route.entryName && responseStream) {
+      responseStream.pipe(res);
       return;
     }
-    res.setHeader("content-type", renderResult.contentType);
-    const { contentStream } = renderResult;
-    if (contentStream) {
-      contentStream.pipe(
-        (0, import_template.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 = (0, import_hook_api.createAfterRenderContext)(
         context,
@@ -397,11 +397,6 @@ class ModernServer {
       if (this.isSend(res)) {
         return;
       }
-      afterRenderContext.template.prependHead(
-        `<script>window._SERVER_DATA=${JSON.stringify(
-          context.serverData
-        )}</script>`
-      );
       response = afterRenderContext.template.get();
     }
     res.end(response);

package/dist/esm/libs/hook-api/index.js

@@ -124,15 +124,10 @@ var Response = /*#__PURE__*/ function() {
         _classCallCheck(this, Response);
         _defineProperty(this, "cookies", void 0);
         _defineProperty(this, "res", void 0);
-        _defineProperty(this, "_cookie", void 0);
         this.res = res;
-        this._cookie = cookie.parse(res.getHeader("set-cookie") || "");
         this.cookies = {
-            get: this.getCookie.bind(this),
             set: this.setCookie.bind(this),
-            delete: this.deleteCookie.bind(this),
-            clear: this.clearCookie.bind(this),
-            apply: this.applyCookie.bind(this)
+            clear: this.clearCookie.bind(this)
         };
     }
     _createClass(Response, [
@@ -154,44 +149,21 @@ var Response = /*#__PURE__*/ function() {
                 this.res.statusCode = code;
             }
         },
-        {
-            key: "getCookie",
-            value: function getCookie(key) {
-                return this._cookie[key];
-            }
-        },
         {
             key: "setCookie",
-            value: function setCookie(key, value) {
-                this._cookie[key] = value;
-            }
-        },
-        {
-            key: "deleteCookie",
-            value: function deleteCookie(key) {
-                if (this._cookie[key]) {
-                    delete this._cookie[key];
-                }
+            value: function setCookie(key, value, options) {
+                var cookieValue = this.res.getHeader("set-cookie");
+                var fmt = Array.isArray(cookieValue) ? cookieValue : [
+                    cookieValue
+                ].filter(Boolean);
+                fmt.push(cookie.serialize(key, value, options));
+                this.res.setHeader("set-cookie", fmt.length === 1 ? fmt[0] : fmt);
             }
         },
         {
             key: "clearCookie",
             value: function clearCookie() {
-                this._cookie = {};
-            }
-        },
-        {
-            key: "applyCookie",
-            value: function applyCookie() {
-                var str = Object.entries(this._cookie).map(function(param) {
-                    var _param = _slicedToArray(param, 2), key = _param[0], value = _param[1];
-                    return cookie.serialize(key, value);
-                }).join("; ");
-                if (str) {
-                    this.res.setHeader("set-cookie", str);
-                } else {
-                    this.res.removeHeader("set-cookie");
-                }
+                this.res.removeHeader("set-cookie");
             }
         },
         {

package/dist/esm/libs/render/index.js

@@ -128,6 +128,7 @@ import { ERROR_DIGEST } from "../../constants";
 import { handleDirectory } from "./static";
 import { readFile } from "./reader";
 import * as ssr from "./ssr";
+import { injectSeverData } from "./utils";
 var createRenderHandler = function(param) {
     var distDir = param.distDir, staticGenerate = param.staticGenerate, forceCSR = param.forceCSR;
     return function() {
@@ -218,7 +219,7 @@ var createRenderHandler = function(param) {
                         return [
                             2,
                             {
-                                content: content,
+                                content: route.entryName ? injectSeverData(content.toString(), ctx) : content,
                                 contentType: mime.contentType(path.extname(templatePath))
                             }
                         ];

package/dist/esm/libs/render/ssr.js

@@ -123,9 +123,11 @@ var __generator = this && this.__generator || function(thisArg, body) {
     }
 };
 import path from "path";
-import { fs, LOADABLE_STATS_FILE, mime, ROUTE_MINIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
+import { fs, mime } from "@modern-js/utils";
+import { LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils/constants";
 import cache from "./cache";
 import { createLogger, createMetrics } from "./measure";
+import { injectServerDataStream, injectSeverData } from "./utils";
 var render = function() {
     var _ref = _asyncToGenerator(function(ctx, renderOptions, runner) {
         var _ctx_res, urlPath, bundle, distDir, template, entryName, staticGenerate, _renderOptions_enableUnsafeCtx, enableUnsafeCtx, bundleJS, loadableUri, loadableStats, routesManifestUri, routeManifest, context, serverRender, content, _context_redirection, url, _context_redirection_status, status;
@@ -136,7 +138,7 @@ var render = function() {
                     bundleJS = path.join(distDir, bundle);
                     loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
                     loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
-                    routesManifestUri = path.join(distDir, ROUTE_MINIFEST_FILE);
+                    routesManifestUri = path.join(distDir, ROUTE_MANIFEST_FILE);
                     routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
                     context = {
                         request: {
@@ -196,7 +198,7 @@ var render = function() {
                         return [
                             2,
                             {
-                                content: content,
+                                content: injectSeverData(content, ctx),
                                 contentType: mime.contentType("html")
                             }
                         ];
@@ -205,7 +207,7 @@ var render = function() {
                             2,
                             {
                                 content: "",
-                                contentStream: content,
+                                contentStream: injectServerDataStream(content, ctx),
                                 contentType: mime.contentType("html")
                             }
                         ];

package/dist/esm/libs/render/utils.js

@@ -0,0 +1,12 @@
+import { TemplateAPI, templateInjectableStream } from "../hook-api/template";
+var injectSeverData = function(content, context) {
+    var template = new TemplateAPI(content);
+    template.prependHead("<script>window._SERVER_DATA=".concat(JSON.stringify(context.serverData), "</script>"));
+    return template.get();
+};
+var injectServerDataStream = function(content, context) {
+    return content.pipe(templateInjectableStream({
+        prependHead: "<script>window._SERVER_DATA=".concat(JSON.stringify(context.serverData), "</script>")
+    }));
+};
+export { injectServerDataStream, injectSeverData };

package/dist/esm/server/index.js

@@ -529,8 +529,8 @@ var Server = /*#__PURE__*/ function() {
                                 defaultEnvPath = path.resolve(appDirectory, ".env");
                                 serverEnvPath = path.resolve(appDirectory, ".env.".concat(serverEnv));
                                 _i = 0, _iter = [
-                                    defaultEnvPath,
-                                    serverEnvPath
+                                    serverEnvPath,
+                                    defaultEnvPath
                                 ];
                                 _state.label = 1;
                             case 1: