@modern-js/prod-server 2.21.0 → 2.22.0

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

@@ -1,78 +1,11 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import cookie from "cookie";
 import { RouteAPI } from "./route";
 import { TemplateAPI } from "./template";
-class Response {
-  get(key) {
-    return this.res.getHeader(key);
-  }
-  set(key, value) {
-    return this.res.setHeader(key, value);
-  }
-  status(code) {
-    this.res.statusCode = code;
-  }
-  setCookie(key, value, options) {
-    const cookieValue = this.res.getHeader("set-cookie");
-    const 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);
-  }
-  clearCookie() {
-    this.res.removeHeader("set-cookie");
-  }
-  raw(body, options) {
-    const { status, headers = {} } = options || {};
-    Object.entries(headers).forEach(([key, value]) => {
-      this.res.setHeader(key, value);
-    });
-    if (status) {
-      this.res.statusCode = status;
-    }
-    this.res.end(body);
-  }
-  constructor(res) {
-    _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)
-    };
-  }
-}
-class Request {
-  getCookie(key) {
-    return this._cookie[key];
-  }
-  constructor(ctx) {
-    _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)
-    };
-  }
-}
+import { BaseRequest, BaseResponse } from "./base";
 export const base = (context) => {
   const { res } = context;
   return {
-    response: new Response(res),
-    request: new Request(context),
+    response: new BaseResponse(res),
+    request: new BaseRequest(context),
     logger: context.logger,
     metrics: context.metrics
   };
@@ -93,12 +26,10 @@ export const createAfterRenderContext = (context, content) => {
 };
 export const createMiddlewareContext = (context) => {
   const baseContext = base(context);
+  baseContext.response.locals = context.res.locals || {};
   return {
     ...baseContext,
-    response: {
-      ...baseContext.response,
-      locals: context.res.locals || {}
-    },
+    response: baseContext.response,
     source: {
       req: context.req,
       res: context.res

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

@@ -0,0 +1,84 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { BaseRequest, BaseResponse } from "./base";
+import { RouteAPI } from "./route";
+import { TemplateAPI } from "./template";
+class ServerResponse {
+  set statusCode(code) {
+    this.res.status = code;
+  }
+  get statusCode() {
+    return this.res.status;
+  }
+  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;
+  }
+  setHeader(key, value) {
+    this.res.headers.set(key, value);
+  }
+  removeHeader(key) {
+    this.res.headers.delete(key);
+  }
+  end(body) {
+    this.res.body = body;
+    this.res.isSent = true;
+  }
+  constructor(res) {
+    _define_property(this, "locals", void 0);
+    _define_property(this, "res", void 0);
+    this.res = res;
+    this.locals = res.locals;
+  }
+}
+export const base = (context) => {
+  const { req, res, logger, metrics } = context;
+  const serverResponse = new ServerResponse(res);
+  const { host, pathname, searchParams } = new URL(req.url);
+  const headers = {};
+  req.headers.forEach((value, key) => {
+    headers[key] = value;
+  });
+  return {
+    response: new BaseResponse(serverResponse),
+    request: new BaseRequest({
+      url: req.url,
+      host,
+      path: pathname,
+      headers,
+      // eslint-disable-next-line node/no-unsupported-features/es-builtins
+      query: Object.fromEntries(searchParams)
+    }),
+    logger,
+    metrics
+  };
+};
+export const createAfterMatchContext = (context, entryName) => {
+  const baseContext = base(context);
+  return {
+    ...baseContext,
+    router: new RouteAPI(entryName)
+  };
+};
+export const createAfterRenderContext = (context, content) => {
+  const baseContext = base(context);
+  return {
+    ...baseContext,
+    template: new TemplateAPI(content)
+  };
+};
+export const createMiddlewareContext = (context) => {
+  const baseContext = base(context);
+  baseContext.response.locals = context.res.locals;
+  const { url, headers } = context.req;
+  const rawRequest = new Request(url, {
+    headers
+  });
+  return {
+    ...baseContext,
+    response: baseContext.response,
+    source: {
+      req: rawRequest,
+      res: baseContext.response
+    }
+  };
+};

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

@@ -1,6 +1,5 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { Transform } from "stream";
-const RegList = {
+export const RegList = {
   before: {
     head: "<head>",
     body: "<body>"
@@ -41,26 +40,3 @@ export class TemplateAPI {
     this.content = content;
   }
 }
-export const templateInjectableStream = ({ prependHead, appendHead, prependBody, appendBody }) => new Transform({
-  write(chunk, _, callback) {
-    let chunk_str = chunk.toString();
-    if (prependHead) {
-      const { head } = RegList.before;
-      chunk_str = chunk_str.replace(head, `${head}${prependHead}`);
-    }
-    if (appendHead) {
-      const { head } = RegList.after;
-      chunk_str = chunk_str.replace(head, `${appendHead}${head}`);
-    }
-    if (prependBody) {
-      const { body } = RegList.before;
-      chunk_str = chunk_str.replace(body, `${body}${prependBody}`);
-    }
-    if (appendBody) {
-      const { body } = RegList.after;
-      chunk_str = chunk_str.replace(body, `${appendBody}${body}`);
-    }
-    this.push(chunk_str);
-    callback();
-  }
-});

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

@@ -0,0 +1,25 @@
+import { Transform } from "stream";
+import { RegList } from "./template";
+export const templateInjectableStream = ({ prependHead, appendHead, prependBody, appendBody }) => new Transform({
+  write(chunk, _, callback) {
+    let chunk_str = chunk.toString();
+    if (prependHead) {
+      const { head } = RegList.before;
+      chunk_str = chunk_str.replace(head, `${head}${prependHead}`);
+    }
+    if (appendHead) {
+      const { head } = RegList.after;
+      chunk_str = chunk_str.replace(head, `${appendHead}${head}`);
+    }
+    if (prependBody) {
+      const { body } = RegList.before;
+      chunk_str = chunk_str.replace(body, `${body}${prependBody}`);
+    }
+    if (appendBody) {
+      const { body } = RegList.after;
+      chunk_str = chunk_str.replace(body, `${appendBody}${body}`);
+    }
+    this.push(chunk_str);
+    callback();
+  }
+});

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

@@ -1,5 +1,5 @@
 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";
@@ -16,9 +16,6 @@ export const createRenderHandler = ({ distDir, staticGenerate, forceCSR, nonce }
     return result;
   }
   const templatePath = entry;
-  if (!fs.existsSync(templatePath)) {
-    throw new Error(`Could not find template file: ${templatePath}`);
-  }
   const content = await readFile(templatePath);
   if (!content) {
     return null;

package/dist/esm-node/libs/render/reader.js

@@ -1,27 +1,28 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { fs } from "@modern-js/utils";
+import { fs as extraFS } from "@modern-js/utils";
 import LRU from "lru-cache";
 const Byte = 1;
 const KB = 1024 * Byte;
 const MB = 1024 * KB;
 const getContentLength = (cache) => cache.content.length;
-const createCacheItem = async (filepath, mtime) => {
-  const content = await fs.readFile(filepath);
+const createCacheItem = async (content, mtime) => {
   return {
     content,
     mtime
   };
 };
 export class LruReader {
-  init() {
+  init(fs) {
+    this.fs = fs || extraFS;
   }
   close() {
   }
   async read(filepath) {
+    const { fs } = this;
     if (this.cache.has(filepath)) {
-      const { content } = this.cache.get(filepath);
+      const { content: content2 } = this.cache.get(filepath);
       return {
-        content
+        content: content2
       };
     }
     if (!fs.existsSync(filepath)) {
@@ -34,12 +35,13 @@ export class LruReader {
     if (stat.size > 20 * MB) {
       return null;
     }
-    const item = await createCacheItem(filepath, stat.mtime);
+    const content = await fs.promises.readFile(filepath);
+    const item = await createCacheItem(content, stat.mtime);
     this.cache.set(filepath, item);
     return item;
   }
   update() {
-    const { cache } = this;
+    const { cache, fs } = this;
     const files = cache.keys();
     for (const filepath of files) {
       if (!fs.existsSync(filepath)) {
@@ -57,14 +59,15 @@ export class LruReader {
       }
     }
   }
-  // private timer?: NodeJS.Timeout;
   constructor() {
     _define_property(this, "cache", void 0);
+    _define_property(this, "fs", void 0);
     this.cache = new LRU({
       max: 256 * MB,
       length: getContentLength,
       maxAge: 5 * 60 * 5e3
     });
+    this.fs = extraFS;
   }
 }
 const reader = new LruReader();
@@ -75,8 +78,8 @@ export const readFile = async (filepath) => {
 export const updateFile = () => {
   reader.update();
 };
-export const init = () => {
-  reader.init();
+export const init = (fs) => {
+  reader.init(fs);
 };
 export const close = () => {
   reader.close();

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

@@ -1,4 +1,5 @@
-import { TemplateAPI, templateInjectableStream } from "../hook-api/template";
+import { TemplateAPI } from "../hook-api/template";
+import { templateInjectableStream } from "../hook-api/templateForStream";
 export const injectServerData = (content, context) => {
   const template = new TemplateAPI(content);
   template.prependHead(`<script type="application/json" id="__MODERN_SERVER_DATA__">${JSON.stringify(context.serverData)}</script>`);

package/dist/esm-node/renderHtml.js

@@ -0,0 +1,71 @@
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { OutgoingMessage } from "http";
+import { Readable } from "stream";
+import { Socket } from "net";
+import { Server } from "./server";
+import { isRedirect } from "./utils";
+class IncomingMessageLike extends Readable {
+  constructor({ method, url, headers }) {
+    super();
+    _define_property(this, "headers", void 0);
+    _define_property(this, "method", void 0);
+    _define_property(this, "url", void 0);
+    _define_property(this, "socket", void 0);
+    this.socket = new Socket();
+    this.headers = headers || {};
+    this.headers.host = "localhost:8080";
+    this.method = method || "get";
+    this.url = url;
+  }
+}
+class ServerResponseLike extends OutgoingMessage {
+  end(chunk, _encoding, cb) {
+    this.data.push(chunk.toString());
+    cb && cb();
+    this.emit("finish");
+    return this;
+  }
+  constructor() {
+    super();
+    _define_property(this, "statusCode", void 0);
+    _define_property(this, "data", void 0);
+    this.statusCode = 200;
+    this.data = [];
+  }
+}
+class CustomServer extends Server {
+  async render(req, res, _url) {
+    const handler = this.getRequestHandler();
+    handler(req, res);
+    return null;
+  }
+}
+async function renderHtml({ url, method, headers, body, serverOptions }) {
+  const req = new IncomingMessageLike({
+    method,
+    url,
+    headers
+  });
+  if (body) {
+    req.push(body);
+    req.push(null);
+  }
+  const res = new ServerResponseLike();
+  const customServer = new CustomServer(serverOptions);
+  await customServer.init({
+    disableHttpServer: true
+  });
+  customServer.render(req, res);
+  return new Promise((resolve) => {
+    res.addListener("finish", () => {
+      resolve({
+        headers: res.getHeaders(),
+        redirected: isRedirect(res.statusCode),
+        status: res.statusCode,
+        url,
+        body: res.data.join()
+      });
+    });
+  });
+}
+module.exports = renderHtml;

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

@@ -21,7 +21,9 @@ export class Server {
   * - 执行 prepare hook
   * - 执行 server init
   */
-  async init() {
+  async init({ disableHttpServer = false } = {
+    disableHttpServer: false
+  }) {
     const { options } = this;
     await this.loadServerEnv(options);
     this.initServerConfig(options);
@@ -31,7 +33,9 @@ export class Server {
     await this.injectContext(this.runner, options);
     this.server = this.serverImpl(options);
     await this.runPrepareHook(this.runner);
-    this.app = await this.server.createHTTPServer(this.getRequestHandler());
+    if (!disableHttpServer) {
+      this.app = await this.server.createHTTPServer(this.getRequestHandler());
+    }
     await this.server.onInit(this.runner, this.app);
     return this;
   }

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

@@ -18,6 +18,7 @@ export class ModernServer {
     var _conf_bff, _this_conf_server, _conf_security, _this_conf_output;
     this.runner = runner;
     const { distDir, staticGenerate, conf } = this;
+    this.initReader();
     debug("final server conf", this.conf);
     this.proxyHandler = createProxyHandler((_conf_bff = conf.bff) === null || _conf_bff === void 0 ? void 0 : _conf_bff.proxy);
     if (this.proxyHandler) {
@@ -25,8 +26,7 @@ export class ModernServer {
         this.addHandler(handler);
       });
     }
-    this.reader.init();
-    app.on("close", () => {
+    app === null || app === void 0 ? void 0 : app.on("close", () => {
       this.reader.close();
     });
     const usageRoutes = this.filterRoutes(this.getRoutes());
@@ -51,18 +51,6 @@ export class ModernServer {
   // server ready
   onRepack(_) {
   }
-  async 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);
-    await this.prepareFrameHandler({
-      onlyWeb,
-      onlyApi
-    });
-  }
   // exposed requestHandler
   getRequestHandler() {
     return this.requestHandler.bind(this);
@@ -89,6 +77,21 @@ export class ModernServer {
     return createServer(handler);
   }
   /* —————————————————————— function will be overwrite —————————————————————— */
+  initReader() {
+    this.reader.init();
+  }
+  async 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);
+    await this.prepareFrameHandler({
+      onlyWeb,
+      onlyApi
+    });
+  }
   // get routes info
   getRoutes() {
     if (this.presetRoutes) {
@@ -452,7 +455,7 @@ export class ModernServer {
     _define_property(this, "staticGenerate", void 0);
     require("ignore-styles");
     this.pwd = pwd;
-    this.distDir = path.join(pwd, config.output.path || "dist");
+    this.distDir = path.resolve(pwd, config.output.path || "dist");
     this.workDir = this.distDir;
     this.conf = config;
     debug("server conf", this.conf);

package/dist/esm-node/workerServer.js

@@ -1,4 +1,6 @@
 import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { createAsyncPipeline } from "@modern-js/plugin";
+import { createAfterMatchContext, createAfterRenderContext, createMiddlewareContext } from "./libs/hook-api/index.worker";
 import { Logger } from "./libs/logger";
 import { RouteMatchManager } from "./libs/route";
 import { metrics as defaultMetrics } from "./libs/metrics";
@@ -44,20 +46,56 @@ export 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 = createAsyncPipeline();
 export const createHandler = (manifest) => {
   const routeMgr = new 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({
+      level: "warn"
+    });
+    const metrics = defaultMetrics;
+    const hookContext = createWorkerHookContext(request.url, logger, metrics);
+    const afterMatchHookContext = 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 = 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,
@@ -70,33 +108,37 @@ export 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({
-            level: "warn"
-          }),
-          metrics: defaultMetrics,
+          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 = 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 = {};
@@ -105,6 +147,8 @@ export const createHandler = (manifest) => {
       });
       const query = Object.fromEntries(searchParams);
       return {
+        url: url2.href,
+        baseUrl,
         pathname,
         host,
         headers,
@@ -121,3 +165,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/types/libs/context/context.d.ts

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/dQl0PkddbjYymDTKBgvwm/src/type" />
+/// <reference types=".dts-temp/t0a-Q86lFJHlugCUZWCMB/src/type" />
 import { IncomingMessage, ServerResponse } from 'http';
 import qs from 'querystring';
 import type { ModernServerContext as ModernServerContextInterface } from '@modern-js/types';