@modern-js/prod-server 1.21.3 → 2.0.0-beta.0

package/CHANGELOG.md

@@ -1,11 +1,51 @@
 # @modern-js/prod-server
 
-## 1.21.3
+## 2.0.0-beta.0
+
+### Major Changes
+
+- dda38c9: chore: v2
+
+### Minor Changes
+
+- c9e800d39: feat: support React18 streaming SSR
+  feat: 支持 React18 流式 SSR
+- 543be95: feat: compile server loader and support handle loader request
+  feat: 编译 server loader 并支持处理 loader 的请求
 
 ### Patch Changes
 
-- @modern-js/server-core@1.21.3
-- @modern-js/utils@1.21.3
+- 15bf09d9c: feat: support completely custom server, export render() api for render single page
+  feat: 支持完全自定义 Server，导出 render() 方法用来渲染单个页面
+- cc971eabf: refactor: move server plugin load logic in `@modern-js/core`
+  refactor：移除在 `@modern-js/core` 中的 server 插件加载逻辑
+- 102d32e4b: feat(server): add `req` and `res` to SSR context
+
+  feat(server): 添加 `req` 和 `res` 到 SSR context 中
+
+- 3bbea92b2: feat: support Hook、Middleware new API
+  feat: 支持 Hook、Middleware 的新 API
+- 73cd29dd9: fix(server): add favicon fallback handler
+
+  fix(server): 添加 favicon 兜底处理逻辑
+
+- 14b712d: fix: use consistent alias type and default value across packages
+
+  fix: 在各个包中使用一致的 alias 类型定义和默认值
+
+- Updated dependencies [15bf09d9c]
+- Updated dependencies [edd1cfb1a]
+- Updated dependencies [cc971eabf]
+- Updated dependencies [5b9049f]
+- Updated dependencies [b8bbe036c]
+- Updated dependencies [d5a31df78]
+- Updated dependencies [dda38c9]
+- Updated dependencies [3bbea92b2]
+- Updated dependencies [abf3421]
+- Updated dependencies [543be95]
+- Updated dependencies [14b712d]
+  - @modern-js/server-core@2.0.0-beta.0
+  - @modern-js/utils@2.0.0-beta.0
 
 ## 1.21.2
 

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

@@ -0,0 +1,156 @@
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); enumerableOnly && (symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; })), keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = null != arguments[i] ? arguments[i] : {}; i % 2 ? ownKeys(Object(source), !0).forEach(function (key) { _defineProperty(target, key, source[key]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)) : ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } return target; }
+
+function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
+
+import cookie from 'cookie';
+import { RouteAPI } from "./route";
+import { TemplateAPI } from "./template";
+
+class Response {
+  constructor(res) {
+    _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)
+    };
+  }
+
+  get(key) {
+    return this.res.getHeader(key);
+  }
+
+  set(key, value) {
+    return this.res.setHeader(key, value);
+  }
+
+  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];
+    }
+  }
+
+  clearCookie() {
+    this._cookie = {};
+  }
+
+  applyCookie() {
+    const str = Object.entries(this._cookie).map(([key, value]) => {
+      return cookie.serialize(key, value);
+    }).join('; ');
+
+    if (str) {
+      this.res.setHeader('set-cookie', str);
+    } else {
+      this.res.removeHeader('set-cookie');
+    }
+  }
+
+  raw(body, {
+    status,
+    headers
+  }) {
+    Object.entries(headers).forEach(([key, value]) => {
+      this.res.setHeader(key, value);
+    });
+
+    if (status) {
+      this.res.statusCode = status;
+    }
+
+    this.res.end(body);
+  }
+
+}
+
+class Request {
+  constructor(ctx) {
+    _defineProperty(this, "host", void 0);
+
+    _defineProperty(this, "pathname", void 0);
+
+    _defineProperty(this, "query", void 0);
+
+    _defineProperty(this, "headers", void 0);
+
+    _defineProperty(this, "cookie", void 0);
+
+    _defineProperty(this, "cookies", void 0);
+
+    _defineProperty(this, "_cookie", void 0);
+
+    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)
+    };
+  }
+
+  getCookie(key) {
+    return this._cookie[key];
+  }
+
+}
+
+export const base = context => {
+  const {
+    res
+  } = context;
+  return {
+    response: new Response(res),
+    request: new Request(context),
+    logger: context.logger,
+    metrics: context.metrics
+  };
+};
+export const createAfterMatchContext = (context, entryName) => {
+  const baseContext = base(context);
+  return _objectSpread(_objectSpread({}, baseContext), {}, {
+    router: new RouteAPI(entryName)
+  });
+};
+export const createAfterRenderContext = (context, content) => {
+  const baseContext = base(context);
+  return _objectSpread(_objectSpread({}, baseContext), {}, {
+    template: new TemplateAPI(content)
+  });
+};
+export const createMiddlewareContext = context => {
+  const baseContext = base(context);
+  return _objectSpread(_objectSpread({}, baseContext), {}, {
+    response: _objectSpread(_objectSpread({}, baseContext.response), {}, {
+      locals: context.res.locals || {}
+    }),
+    source: {
+      req: context.req,
+      res: context.res
+    }
+  });
+};

package/dist/js/modern/libs/hook-api/route.js

@@ -1,44 +1,29 @@
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
-class RouteAPI {
-  constructor(matched, router, url) {
-    _defineProperty(this, "router", void 0);
-
+export class RouteAPI {
+  constructor(entryName) {
     _defineProperty(this, "current", void 0);
 
+    _defineProperty(this, "status", void 0);
+
     _defineProperty(this, "url", void 0);
 
-    this.current = matched;
-    this.router = router;
-    this.url = url;
+    this.current = entryName;
+    this.status = 200;
+    this.url = '';
   }
 
-  cur() {
-    return this.current.generate(this.url);
+  redirect(url, status = 302) {
+    this.url = url;
+    this.status = status;
   }
 
-  get(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-    return matched ? matched.generate(this.url) : null;
+  rewrite(entryName) {
+    this.current = entryName;
   }
 
   use(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-
-    if (matched) {
-      this.current = matched;
-      return true;
-    } else {
-      return false;
-    }
+    this.rewrite(entryName);
   }
 
-}
-
-export const createRouteAPI = (matched, router, url) => new RouteAPI(matched, router, url);
+}

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

@@ -1,5 +1,6 @@
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+import { Transform } from 'stream';
 const RegList = {
   before: {
     head: '<head>',
@@ -10,8 +11,7 @@ const RegList = {
     body: '</body>'
   }
 };
-
-class TemplateAPI {
+export class TemplateAPI {
   constructor(content) {
     _defineProperty(this, "content", void 0);
 
@@ -56,9 +56,48 @@ class TemplateAPI {
 
   replace(reg, text) {
     this.content = this.content.replace(reg, text);
-    return this;
   }
 
 }
+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();
+  }
 
-export const createTemplateAPI = content => new TemplateAPI(content);
+});

package/dist/js/modern/libs/render/cache/index.js

@@ -4,6 +4,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+import { Transform } from 'stream';
 import { ERROR_DIGEST } from "../../../constants";
 import { createCache } from "./spr";
 import { namespaceHash, withCoalescedInvoke } from "./util";
@@ -15,10 +16,28 @@ export default ((renderFn, ctx) => {
       entry: context.entryName
     }, context.request);
 
-    const cacheFile = await sprCache.get(cacheContext); // no cache, render sync
+    const cacheFile = await sprCache.get(cacheContext);
 
-    if (!cacheFile) {
-      const html = await renderFn(context);
+    async function afterRender(source, onAfterRender) {
+      if (typeof source === 'string') {
+        await onAfterRender(source);
+        return source;
+      } else {
+        let htmlForStream = '';
+        const cacheStream = new Transform({
+          write(chunk, _, callback) {
+            htmlForStream += chunk.toString();
+            this.push(chunk);
+            callback();
+          }
+
+        });
+        cacheStream.on('close', () => onAfterRender(htmlForStream));
+        return source(cacheStream);
+      }
+    }
+
+    async function saveHtmlIntoCache(html) {
       const {
         cacheConfig
       } = context;
@@ -26,34 +45,32 @@ export default ((renderFn, ctx) => {
       if (html && cacheConfig) {
         await sprCache.set(cacheContext, html, cacheConfig);
       }
+    } // no cache, render sync
 
-      return html;
+
+    if (!cacheFile) {
+      const renderResult = await renderFn(context);
+      return afterRender(renderResult, saveHtmlIntoCache);
     }
 
     const cacheHash = cacheFile === null || cacheFile === void 0 ? void 0 : cacheFile.hash; // completely expired
 
     if (cacheFile.isGarbage) {
-      const html = await renderFn(context);
-      const {
-        cacheConfig
-      } = context;
-
-      if (html && cacheConfig) {
-        await sprCache.set(cacheContext, html, cacheConfig);
-      }
-
-      return html;
+      const renderResult = await renderFn(context);
+      return afterRender(renderResult, saveHtmlIntoCache);
     } else if (cacheFile.isStale) {
       // if file is stale, request async
       const render = withCoalescedInvoke(() => renderFn(context)).bind(null, namespaceHash('render', cacheFile.hash), []);
-      render().then(res => {
+      render().then(async res => {
         if (res.value && res.isOrigin) {
           const {
             cacheConfig
           } = context;
 
           if (cacheConfig) {
-            sprCache.set(cacheContext, res.value, cacheConfig);
+            afterRender(res.value, async html => {
+              sprCache.set(cacheContext, html, cacheConfig);
+            });
           } else {
             sprCache.del(cacheContext, cacheHash);
           }

package/dist/js/modern/libs/render/measure.js

@@ -4,6 +4,7 @@ function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { va
 
 function _defineProperty(obj, key, value) { if (key in obj) { Object.defineProperty(obj, key, { value: value, enumerable: true, configurable: true, writable: true }); } else { obj[key] = value; } return obj; }
 
+/* eslint-disable no-param-reassign */
 import { headersWithoutCookie } from "../../utils";
 export const createMetrics = (context, metrics) => {
   const {
@@ -49,6 +50,11 @@ export const createLogger = (serverContext, logger) => {
   };
 
   const error = (message, e) => {
+    if (!e) {
+      e = message;
+      message = '';
+    }
+
     logger.error(`SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, pathname, headersWithoutCookie(headers));
   };
 
@@ -57,4 +63,5 @@ export const createLogger = (serverContext, logger) => {
     info,
     debug
   };
-};
+};
+/* eslint-enable no-param-reassign */

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

@@ -4,6 +4,8 @@ import cookie from 'cookie';
 import cache from "./cache";
 import { createLogger, createMetrics } from "./measure";
 export const render = async (ctx, renderOptions, runner) => {
+  var _ctx$res;
+
   const {
     urlPath,
     bundle,
@@ -32,7 +34,8 @@ export const render = async (ctx, renderOptions, runner) => {
       },
       status: code => {
         ctx.res.statusCode = code;
-      }
+      },
+      locals: ((_ctx$res = ctx.res) === null || _ctx$res === void 0 ? void 0 : _ctx$res.locals) || {}
     },
     redirection: {},
     template,
@@ -40,7 +43,9 @@ export const render = async (ctx, renderOptions, runner) => {
     entryName,
     staticGenerate,
     logger: undefined,
-    metrics: undefined
+    metrics: undefined,
+    req: ctx.req,
+    res: ctx.res
   };
   context.logger = createLogger(context, ctx.logger);
   context.metrics = createMetrics(context, ctx.metrics);
@@ -48,7 +53,7 @@ export const render = async (ctx, renderOptions, runner) => {
 
   const serverRender = require(bundleJS)[SERVER_RENDER_FUNCTION_NAME];
 
-  const html = await cache(serverRender, ctx)(context);
+  const content = await cache(serverRender, ctx)(context);
   const {
     url,
     status = 302
@@ -63,8 +68,16 @@ export const render = async (ctx, renderOptions, runner) => {
     };
   }
 
-  return {
-    content: html,
-    contentType: mime.contentType('html')
-  };
+  if (typeof content === 'string') {
+    return {
+      content,
+      contentType: mime.contentType('html')
+    };
+  } else {
+    return {
+      content: '',
+      contentStream: content,
+      contentType: mime.contentType('html')
+    };
+  }
 };

package/dist/js/modern/libs/serve-file.js

@@ -15,6 +15,14 @@ const removedPrefix = (req, prefix) => {
   }
 };
 
+export const faviconFallbackHandler = (context, next) => {
+  if (context.url === '/favicon.ico') {
+    context.res.statusCode = 204;
+    context.res.end();
+  } else {
+    next();
+  }
+};
 export const createStaticFileHandler = (rules, output = {}) => // eslint-disable-next-line consistent-return
 async (context, next) => {
   const {

package/dist/js/modern/server/index.js

@@ -6,7 +6,7 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 import path from 'path';
 import fs from 'fs';
-import { Logger, SHARED_DIR, OUTPUT_CONFIG_FILE, dotenv, dotenvExpand } from '@modern-js/utils';
+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";
@@ -146,6 +146,10 @@ export class Server {
     };
   }
 
+  async render(req, res, url) {
+    return this.server.render(req, res, url);
+  }
+
   async createHookRunner() {
     // clear server manager every create time
     serverManager.clear();
@@ -154,13 +158,15 @@ export class Server {
     } = this; // TODO: 确认下这里是不是可以不从 options 中取插件，而是从 config 中取和过滤
 
     const {
-      plugins = [],
+      internalPlugins = INTERNAL_SERVER_PLUGINS,
       pwd,
       config
     } = options;
     const serverPlugins = this.serverConfig.plugins || []; // server app context for serve plugin
 
-    const loadedPlugins = loadPlugins(plugins.concat(serverPlugins), pwd);
+    const loadedPlugins = loadPlugins(pwd, serverPlugins, {
+      internalPlugins
+    });
     debug('plugins', config.plugins, loadedPlugins);
     loadedPlugins.forEach(p => {
       serverManager.usePlugin(p);

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

@@ -1,4 +1,3 @@
-import { RUN_MODE } from "../constants";
 import { ModernServer } from "./modern-server";
 
 class ModernSSRServer extends ModernServer {
@@ -6,20 +5,8 @@ class ModernSSRServer extends ModernServer {
     return null;
   }
 
-  filterRoutes(routes) {
-    return routes.filter(route => !route.isApi);
-  }
-
-  async setupBeforeProdMiddleware() {
-    if (this.runMode === RUN_MODE.FULL) {
-      await super.setupBeforeProdMiddleware();
-    }
-  }
-
-  async emitRouteHook(_, _input) {
-    if (this.runMode === RUN_MODE.FULL) {
-      await super.emitRouteHook(_, _input);
-    }
+  async handleAPI(context) {
+    return this.render404(context);
   }
 
 }
@@ -33,15 +20,6 @@ class ModernAPIServer extends ModernServer {
     return routes.filter(route => route.isApi);
   }
 
-  async setupBeforeProdMiddleware() {
-    if (this.runMode === RUN_MODE.FULL) {
-      await super.setupBeforeProdMiddleware();
-    }
-  }
-
-  async emitRouteHook(_, _input) {// empty
-  }
-
 }
 
 class ModernWebServer extends ModernServer {
@@ -50,29 +28,12 @@ class ModernWebServer extends ModernServer {
   }
 
   async handleAPI(context) {
-    const {
-      proxyTarget
-    } = this;
-
-    if (proxyTarget !== null && proxyTarget !== void 0 && proxyTarget.api) {
-      return this.proxy();
-    } else {
-      return this.render404(context);
-    }
+    return this.render404(context);
   }
 
   async handleWeb(context, route) {
-    const {
-      proxyTarget
-    } = this;
-
-    if (route.isSSR && proxyTarget !== null && proxyTarget !== void 0 && proxyTarget.ssr) {
-      return this.proxy();
-    } else {
-      // if no proxyTarget but access web server, degradation to csr
-      route.isSSR = false;
-      return super.handleWeb(context, route);
-    }
+    route.isSSR = false;
+    return super.handleWeb(context, route);
   }
 
 }