@modern-js/prod-server 2.21.0 → 2.22.0

package/dist/cjs/workerServer.js

@@ -10,10 +10,16 @@ function _export(target, all) {
     });
 }
 _export(exports, {
-  ReturnResponse: () => ReturnResponse,
-  createHandler: () => createHandler
+  ReturnResponse: function() {
+    return ReturnResponse;
+  },
+  createHandler: function() {
+    return createHandler;
+  }
 });
 const _define_property = require("@swc/helpers/_/_define_property");
+const _plugin = require("@modern-js/plugin");
+const _indexworker = require("./libs/hook-api/index.worker");
 const _logger = require("./libs/logger");
 const _route = require("./libs/route");
 const _metrics = require("./libs/metrics");
@@ -59,20 +65,56 @@ class ReturnResponse {
   }
 }
 const RESPONSE_NOTFOUND = new ReturnResponse("404: Page not found", 404);
+const isRedirect = (code) => {
+  return [
+    301,
+    302,
+    307,
+    308
+  ].includes(code);
+};
+const checkIsSent = (context) => {
+  if (context.res.isSent) {
+    return true;
+  }
+  if (context.res.headers.get("Location") && isRedirect(context.res.status)) {
+    return true;
+  }
+  return false;
+};
+const middlewarePipeline = (0, _plugin.createAsyncPipeline)();
 const createHandler = (manifest) => {
   const routeMgr = new _route.RouteMatchManager();
   const { pages, routes } = manifest;
   routeMgr.reset(routes);
   return async (options) => {
+    var _page_serverHooks, _page_serverHooks_afterMatch;
     const { request, loadableStats, routeManifest } = options;
     const url = new URL(request.url);
     const pageMatch = routeMgr.match(url.pathname);
     if (!pageMatch) {
       return RESPONSE_NOTFOUND;
     }
-    const page = pages[pageMatch.spec.urlPath];
+    const entryName = pageMatch.spec.urlPath;
+    const page = pages[entryName];
+    const logger = new _logger.Logger({
+      level: "warn"
+    });
+    const metrics = _metrics.metrics;
+    const hookContext = createWorkerHookContext(request.url, logger, metrics);
+    const afterMatchHookContext = (0, _indexworker.createAfterMatchContext)(hookContext, entryName);
+    page === null || page === void 0 ? void 0 : (_page_serverHooks = page.serverHooks) === null || _page_serverHooks === void 0 ? void 0 : (_page_serverHooks_afterMatch = _page_serverHooks.afterMatch) === null || _page_serverHooks_afterMatch === void 0 ? void 0 : _page_serverHooks_afterMatch.call(_page_serverHooks, afterMatchHookContext, () => void 0);
+    if (checkIsSent(hookContext)) {
+      return new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers);
+    }
     if (page.serverRender) {
       try {
+        var _page_serverHooks1, _page_serverHooks2, _page_serverHooks_afterRender;
+        const middlewarsHookContext = (0, _indexworker.createMiddlewareContext)(hookContext);
+        applyMiddlewares(middlewarsHookContext, (_page_serverHooks1 = page.serverHooks) === null || _page_serverHooks1 === void 0 ? void 0 : _page_serverHooks1.middleware);
+        if (checkIsSent(hookContext)) {
+          return new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers);
+        }
         const responseLike = {
           headers: {},
           statusCode: 200,
@@ -85,33 +127,37 @@ const createHandler = (manifest) => {
           }
         };
         const params = pageMatch.parseURLParams(url.pathname) || {};
+        const { urlPath: baseUrl } = pageMatch;
         const serverRenderContext = {
-          request: createServerRequest(url, request, params),
+          request: createServerRequest(url, baseUrl, request, params),
           response: responseLike,
           loadableStats,
           routeManifest,
           redirection: {},
           template: page.template,
           entryName: page.entryName,
-          logger: new _logger.Logger({
-            level: "warn"
-          }),
-          metrics: _metrics.metrics,
+          logger,
+          metrics,
           // FIXME: pass correctly req & res
           req: request,
           res: responseLike
         };
         const body = await page.serverRender(serverRenderContext);
-        return new ReturnResponse(body, responseLike.statusCode, responseLike.headers);
+        const afterRenderHookContext = (0, _indexworker.createAfterRenderContext)(hookContext, body);
+        (_page_serverHooks2 = page.serverHooks) === null || _page_serverHooks2 === void 0 ? void 0 : (_page_serverHooks_afterRender = _page_serverHooks2.afterRender) === null || _page_serverHooks_afterRender === void 0 ? void 0 : _page_serverHooks_afterRender.call(_page_serverHooks2, afterRenderHookContext, () => void 0);
+        if (checkIsSent(hookContext)) {
+          return new ReturnResponse(hookContext.res.body || "Unkown body", hookContext.res.status, hookContext.res.headers);
+        }
+        return new ReturnResponse(afterRenderHookContext.template.get(), responseLike.statusCode, responseLike.headers);
       } catch (e) {
         console.warn(`page(${pageMatch.spec.urlPath}) serverRender occur error: `);
         console.warn(e);
         return createResponse(page.template);
       }
     }
-    console.warn(`Can't not page(${pageMatch.spec.urlPath}) serverRender`);
+    console.warn(`Can't not page(${entryName}) serverRender`);
     return createResponse(page.template);
-    function createServerRequest(url2, request2, params) {
+    function createServerRequest(url2, baseUrl, request2, params) {
       const { pathname, host, searchParams } = url2;
       const { headers: rawHeaders } = request2;
       const headers = {};
@@ -120,6 +166,8 @@ const createHandler = (manifest) => {
       });
       const query = Object.fromEntries(searchParams);
       return {
+        url: url2.href,
+        baseUrl,
         pathname,
         host,
         headers,
@@ -136,3 +184,39 @@ function createResponse(template) {
     return RESPONSE_NOTFOUND;
   }
 }
+function createWorkerHookContext(url, logger, metrics) {
+  const [res, req] = [
+    {
+      headers: new Headers(),
+      body: "",
+      status: 200,
+      isSent: false
+    },
+    new Request(url)
+  ];
+  return {
+    res,
+    req,
+    logger,
+    metrics
+  };
+}
+function applyMiddlewares(ctx, middleware) {
+  if (middleware) {
+    const middlewares = (() => {
+      if (Array.isArray(middleware)) {
+        return middleware;
+      } else {
+        return [
+          middleware
+        ];
+      }
+    })();
+    middlewares.forEach((middleware2) => {
+      middlewarePipeline.use(middleware2);
+    });
+    middlewarePipeline.run(ctx, {
+      onLast: () => void 0
+    });
+  }
+}

package/dist/esm/libs/context/context.js

@@ -160,7 +160,7 @@ export var ModernServerContext = /* @__PURE__ */ function() {
         if (!host) {
           host = this.getReqHeader("Host");
         }
-        return host.split(/\s*,\s*/, 1)[0] || "";
+        return host.split(/\s*,\s*/, 1)[0] || "undefined";
       }
     },
     {

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

@@ -0,0 +1,104 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
+import cookie from "cookie";
+export var BaseResponse = /* @__PURE__ */ function() {
+  "use strict";
+  function BaseResponse2(res) {
+    _class_call_check(this, BaseResponse2);
+    _define_property(this, "cookies", void 0);
+    _define_property(this, "res", void 0);
+    this.res = res;
+    this.cookies = {
+      set: this.setCookie.bind(this),
+      clear: this.clearCookie.bind(this)
+    };
+  }
+  _create_class(BaseResponse2, [
+    {
+      key: "get",
+      value: function get(key) {
+        return this.res.getHeader(key);
+      }
+    },
+    {
+      key: "set",
+      value: function set(key, value) {
+        return this.res.setHeader(key, value);
+      }
+    },
+    {
+      key: "status",
+      value: function status(code) {
+        this.res.statusCode = code;
+      }
+    },
+    {
+      key: "setCookie",
+      value: function setCookie(key, value, options) {
+        var cookieValue = String(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.res.removeHeader("set-cookie");
+      }
+    },
+    {
+      key: "raw",
+      value: function raw(body, options) {
+        var _this = this;
+        var _ref = options || {}, status = _ref.status, _ref_headers = _ref.headers, headers = _ref_headers === void 0 ? {} : _ref_headers;
+        Object.entries(headers).forEach(function(param) {
+          var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
+          _this.res.setHeader(key, value);
+        });
+        if (status) {
+          this.res.statusCode = status;
+        }
+        this.res.end(body);
+      }
+    }
+  ]);
+  return BaseResponse2;
+}();
+export var BaseRequest = /* @__PURE__ */ function() {
+  "use strict";
+  function BaseRequest2(request) {
+    _class_call_check(this, BaseRequest2);
+    _define_property(this, "url", void 0);
+    _define_property(this, "host", void 0);
+    _define_property(this, "pathname", void 0);
+    _define_property(this, "query", void 0);
+    _define_property(this, "headers", void 0);
+    _define_property(this, "cookie", void 0);
+    _define_property(this, "cookies", void 0);
+    _define_property(this, "_cookie", void 0);
+    this.url = request.url;
+    this.host = request.host;
+    this.pathname = request.path;
+    this.query = request.query;
+    this.headers = request.headers;
+    this.cookie = request.headers.cookie || "";
+    this._cookie = cookie.parse(this.cookie);
+    this.cookies = {
+      get: this.getCookie.bind(this)
+    };
+  }
+  _create_class(BaseRequest2, [
+    {
+      key: "getCookie",
+      value: function getCookie(key) {
+        return this._cookie[key];
+      }
+    }
+  ]);
+  return BaseRequest2;
+}();

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

@@ -1,116 +1,13 @@
-import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
-import { _ as _create_class } from "@swc/helpers/_/_create_class";
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
 import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
 import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
-import { _ as _sliced_to_array } from "@swc/helpers/_/_sliced_to_array";
-import cookie from "cookie";
 import { RouteAPI } from "./route";
 import { TemplateAPI } from "./template";
-var Response = /* @__PURE__ */ function() {
-  "use strict";
-  function Response2(res) {
-    _class_call_check(this, Response2);
-    _define_property(this, "cookies", void 0);
-    _define_property(this, "res", void 0);
-    this.res = res;
-    this.cookies = {
-      set: this.setCookie.bind(this),
-      clear: this.clearCookie.bind(this)
-    };
-  }
-  _create_class(Response2, [
-    {
-      key: "get",
-      value: function get(key) {
-        return this.res.getHeader(key);
-      }
-    },
-    {
-      key: "set",
-      value: function set(key, value) {
-        return this.res.setHeader(key, value);
-      }
-    },
-    {
-      key: "status",
-      value: function status(code) {
-        this.res.statusCode = code;
-      }
-    },
-    {
-      key: "setCookie",
-      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.res.removeHeader("set-cookie");
-      }
-    },
-    {
-      key: "raw",
-      value: function raw(body, options) {
-        var _this = this;
-        var _ref = options || {}, status = _ref.status, _ref_headers = _ref.headers, headers = _ref_headers === void 0 ? {} : _ref_headers;
-        Object.entries(headers).forEach(function(param) {
-          var _param = _sliced_to_array(param, 2), key = _param[0], value = _param[1];
-          _this.res.setHeader(key, value);
-        });
-        if (status) {
-          this.res.statusCode = status;
-        }
-        this.res.end(body);
-      }
-    }
-  ]);
-  return Response2;
-}();
-var Request = /* @__PURE__ */ function() {
-  "use strict";
-  function Request2(ctx) {
-    _class_call_check(this, Request2);
-    _define_property(this, "url", void 0);
-    _define_property(this, "host", void 0);
-    _define_property(this, "pathname", void 0);
-    _define_property(this, "query", void 0);
-    _define_property(this, "headers", void 0);
-    _define_property(this, "cookie", void 0);
-    _define_property(this, "cookies", void 0);
-    _define_property(this, "_cookie", void 0);
-    this.url = ctx.url;
-    this.host = ctx.host;
-    this.pathname = ctx.path;
-    this.query = ctx.query;
-    this.headers = ctx.headers;
-    this.cookie = ctx.headers.cookie || "";
-    this._cookie = cookie.parse(this.cookie);
-    this.cookies = {
-      get: this.getCookie.bind(this)
-    };
-  }
-  _create_class(Request2, [
-    {
-      key: "getCookie",
-      value: function getCookie(key) {
-        return this._cookie[key];
-      }
-    }
-  ]);
-  return Request2;
-}();
+import { BaseRequest, BaseResponse } from "./base";
 export var base = function(context) {
   var res = context.res;
   return {
-    response: new Response(res),
-    request: new Request(context),
+    response: new BaseResponse(res),
+    request: new BaseRequest(context),
     logger: context.logger,
     metrics: context.metrics
   };
@@ -129,10 +26,9 @@ export var createAfterRenderContext = function(context, content) {
 };
 export var createMiddlewareContext = function(context) {
   var baseContext = base(context);
+  baseContext.response.locals = context.res.locals || {};
   return _object_spread_props(_object_spread({}, baseContext), {
-    response: _object_spread_props(_object_spread({}, baseContext.response), {
-      locals: context.res.locals || {}
-    }),
+    response: baseContext.response,
     source: {
       req: context.req,
       res: context.res

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

@@ -0,0 +1,105 @@
+import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
+import { _ as _create_class } from "@swc/helpers/_/_create_class";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { BaseRequest, BaseResponse } from "./base";
+import { RouteAPI } from "./route";
+import { TemplateAPI } from "./template";
+var ServerResponse = /* @__PURE__ */ function() {
+  "use strict";
+  function ServerResponse2(res) {
+    _class_call_check(this, ServerResponse2);
+    _define_property(this, "locals", void 0);
+    _define_property(this, "res", void 0);
+    this.res = res;
+    this.locals = res.locals;
+  }
+  _create_class(ServerResponse2, [
+    {
+      key: "statusCode",
+      get: function get() {
+        return this.res.status;
+      },
+      set: function set(code) {
+        this.res.status = code;
+      }
+    },
+    {
+      key: "getHeader",
+      value: function getHeader(key) {
+        var _this_res_headers_get;
+        return (_this_res_headers_get = this.res.headers.get(key)) !== null && _this_res_headers_get !== void 0 ? _this_res_headers_get : void 0;
+      }
+    },
+    {
+      key: "setHeader",
+      value: function setHeader(key, value) {
+        this.res.headers.set(key, value);
+      }
+    },
+    {
+      key: "removeHeader",
+      value: function removeHeader(key) {
+        this.res.headers.delete(key);
+      }
+    },
+    {
+      key: "end",
+      value: function end(body) {
+        this.res.body = body;
+        this.res.isSent = true;
+      }
+    }
+  ]);
+  return ServerResponse2;
+}();
+export var base = function(context) {
+  var req = context.req, res = context.res, logger = context.logger, metrics = context.metrics;
+  var serverResponse = new ServerResponse(res);
+  var _ref = new URL(req.url), host = _ref.host, pathname = _ref.pathname, searchParams = _ref.searchParams;
+  var headers = {};
+  req.headers.forEach(function(value, key) {
+    headers[key] = value;
+  });
+  return {
+    response: new BaseResponse(serverResponse),
+    request: new BaseRequest({
+      url: req.url,
+      host: host,
+      path: pathname,
+      headers: headers,
+      // eslint-disable-next-line node/no-unsupported-features/es-builtins
+      query: Object.fromEntries(searchParams)
+    }),
+    logger: logger,
+    metrics: metrics
+  };
+};
+export var createAfterMatchContext = function(context, entryName) {
+  var baseContext = base(context);
+  return _object_spread_props(_object_spread({}, baseContext), {
+    router: new RouteAPI(entryName)
+  });
+};
+export var createAfterRenderContext = function(context, content) {
+  var baseContext = base(context);
+  return _object_spread_props(_object_spread({}, baseContext), {
+    template: new TemplateAPI(content)
+  });
+};
+export var createMiddlewareContext = function(context) {
+  var baseContext = base(context);
+  baseContext.response.locals = context.res.locals;
+  var _context_req = context.req, url = _context_req.url, headers = _context_req.headers;
+  var rawRequest = new Request(url, {
+    headers: headers
+  });
+  return _object_spread_props(_object_spread({}, baseContext), {
+    response: baseContext.response,
+    source: {
+      req: rawRequest,
+      res: baseContext.response
+    }
+  });
+};

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

@@ -1,8 +1,7 @@
 import { _ as _class_call_check } from "@swc/helpers/_/_class_call_check";
 import { _ as _create_class } from "@swc/helpers/_/_create_class";
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { Transform } from "stream";
-var RegList = {
+export var RegList = {
   before: {
     head: "<head>",
     body: "<body>"
@@ -69,29 +68,3 @@ export var TemplateAPI = /* @__PURE__ */ function() {
   ]);
   return TemplateAPI2;
 }();
-export var templateInjectableStream = function(param) {
-  var prependHead = param.prependHead, appendHead = param.appendHead, prependBody = param.prependBody, appendBody = param.appendBody;
-  return new Transform({
-    write: function write(chunk, _, callback) {
-      var chunk_str = chunk.toString();
-      if (prependHead) {
-        var head = RegList.before.head;
-        chunk_str = chunk_str.replace(head, "".concat(head).concat(prependHead));
-      }
-      if (appendHead) {
-        var head1 = RegList.after.head;
-        chunk_str = chunk_str.replace(head1, "".concat(appendHead).concat(head1));
-      }
-      if (prependBody) {
-        var body = RegList.before.body;
-        chunk_str = chunk_str.replace(body, "".concat(body).concat(prependBody));
-      }
-      if (appendBody) {
-        var body1 = RegList.after.body;
-        chunk_str = chunk_str.replace(body1, "".concat(appendBody).concat(body1));
-      }
-      this.push(chunk_str);
-      callback();
-    }
-  });
-};

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

@@ -0,0 +1,28 @@
+import { Transform } from "stream";
+import { RegList } from "./template";
+export var templateInjectableStream = function(param) {
+  var prependHead = param.prependHead, appendHead = param.appendHead, prependBody = param.prependBody, appendBody = param.appendBody;
+  return new Transform({
+    write: function write(chunk, _, callback) {
+      var chunk_str = chunk.toString();
+      if (prependHead) {
+        var head = RegList.before.head;
+        chunk_str = chunk_str.replace(head, "".concat(head).concat(prependHead));
+      }
+      if (appendHead) {
+        var head1 = RegList.after.head;
+        chunk_str = chunk_str.replace(head1, "".concat(appendHead).concat(head1));
+      }
+      if (prependBody) {
+        var body = RegList.before.body;
+        chunk_str = chunk_str.replace(body, "".concat(body).concat(prependBody));
+      }
+      if (appendBody) {
+        var body1 = RegList.after.body;
+        chunk_str = chunk_str.replace(body1, "".concat(appendBody).concat(body1));
+      }
+      this.push(chunk_str);
+      callback();
+    }
+  });
+};

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

@@ -1,7 +1,7 @@
 import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
 import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
 import path from "path";
-import { fs, mime } from "@modern-js/utils";
+import { mime } from "@modern-js/utils";
 import { ERROR_DIGEST } from "../../constants";
 import { handleDirectory } from "./static";
 import { readFile } from "./reader";
@@ -41,9 +41,6 @@ export var createRenderHandler = function(param) {
             ];
           case 2:
             templatePath = entry;
-            if (!fs.existsSync(templatePath)) {
-              throw new Error("Could not find template file: ".concat(templatePath));
-            }
             return [
               4,
               readFile(templatePath)