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

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

@@ -0,0 +1,184 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { Transform } from 'stream';
+import { ERROR_DIGEST } from "../../../constants";
+import { createCache } from "./spr";
+import { namespaceHash, withCoalescedInvoke } from "./util";
+export default (function (renderFn, ctx) {
+  var sprCache = createCache();
+  var doRender = /*#__PURE__*/function () {
+    var _ref = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(context) {
+      var cacheContext, cacheFile, afterRender, _afterRender, saveHtmlIntoCache, _saveHtmlIntoCache, renderResult, cacheHash, _renderResult, render;
+      return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+        while (1) {
+          switch (_context5.prev = _context5.next) {
+            case 0:
+              _saveHtmlIntoCache = function _saveHtmlIntoCache3() {
+                _saveHtmlIntoCache = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(html) {
+                  var cacheConfig;
+                  return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+                    while (1) {
+                      switch (_context4.prev = _context4.next) {
+                        case 0:
+                          cacheConfig = context.cacheConfig;
+                          if (!(html && cacheConfig)) {
+                            _context4.next = 4;
+                            break;
+                          }
+                          _context4.next = 4;
+                          return sprCache.set(cacheContext, html, cacheConfig);
+                        case 4:
+                        case "end":
+                          return _context4.stop();
+                      }
+                    }
+                  }, _callee4);
+                }));
+                return _saveHtmlIntoCache.apply(this, arguments);
+              };
+              saveHtmlIntoCache = function _saveHtmlIntoCache2(_x4) {
+                return _saveHtmlIntoCache.apply(this, arguments);
+              };
+              _afterRender = function _afterRender3() {
+                _afterRender = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3(source, onAfterRender) {
+                  var htmlForStream, cacheStream;
+                  return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                    while (1) {
+                      switch (_context3.prev = _context3.next) {
+                        case 0:
+                          if (source) {
+                            _context3.next = 2;
+                            break;
+                          }
+                          return _context3.abrupt("return", '');
+                        case 2:
+                          if (!(typeof source === 'string')) {
+                            _context3.next = 8;
+                            break;
+                          }
+                          _context3.next = 5;
+                          return onAfterRender(source);
+                        case 5:
+                          return _context3.abrupt("return", source);
+                        case 8:
+                          htmlForStream = '';
+                          cacheStream = new Transform({
+                            write: function write(chunk, _, callback) {
+                              htmlForStream += chunk.toString();
+                              this.push(chunk);
+                              callback();
+                            }
+                          });
+                          cacheStream.on('close', function () {
+                            return onAfterRender(htmlForStream);
+                          });
+                          return _context3.abrupt("return", source(cacheStream));
+                        case 12:
+                        case "end":
+                          return _context3.stop();
+                      }
+                    }
+                  }, _callee3);
+                }));
+                return _afterRender.apply(this, arguments);
+              };
+              afterRender = function _afterRender2(_x2, _x3) {
+                return _afterRender.apply(this, arguments);
+              };
+              cacheContext = _objectSpread({
+                entry: context.entryName
+              }, context.request);
+              _context5.next = 7;
+              return sprCache.get(cacheContext);
+            case 7:
+              cacheFile = _context5.sent;
+              if (cacheFile) {
+                _context5.next = 13;
+                break;
+              }
+              _context5.next = 11;
+              return renderFn(context);
+            case 11:
+              renderResult = _context5.sent;
+              return _context5.abrupt("return", afterRender(renderResult, saveHtmlIntoCache));
+            case 13:
+              cacheHash = cacheFile === null || cacheFile === void 0 ? void 0 : cacheFile.hash; // completely expired
+              if (!cacheFile.isGarbage) {
+                _context5.next = 21;
+                break;
+              }
+              _context5.next = 17;
+              return renderFn(context);
+            case 17:
+              _renderResult = _context5.sent;
+              return _context5.abrupt("return", afterRender(_renderResult, saveHtmlIntoCache));
+            case 21:
+              if (cacheFile.isStale) {
+                // if file is stale, request async
+                render = withCoalescedInvoke(function () {
+                  return renderFn(context);
+                }).bind(null, namespaceHash('render', cacheFile.hash), []);
+                render().then( /*#__PURE__*/function () {
+                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(res) {
+                    var cacheConfig;
+                    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+                      while (1) {
+                        switch (_context2.prev = _context2.next) {
+                          case 0:
+                            if (res.value && res.isOrigin) {
+                              cacheConfig = context.cacheConfig;
+                              if (cacheConfig) {
+                                afterRender(res.value, /*#__PURE__*/function () {
+                                  var _ref3 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(html) {
+                                    return _regeneratorRuntime().wrap(function _callee$(_context) {
+                                      while (1) {
+                                        switch (_context.prev = _context.next) {
+                                          case 0:
+                                            sprCache.set(cacheContext, html, cacheConfig);
+                                          case 1:
+                                          case "end":
+                                            return _context.stop();
+                                        }
+                                      }
+                                    }, _callee);
+                                  }));
+                                  return function (_x6) {
+                                    return _ref3.apply(this, arguments);
+                                  };
+                                }());
+                              } else {
+                                sprCache.del(cacheContext, cacheHash);
+                              }
+                            }
+                          case 1:
+                          case "end":
+                            return _context2.stop();
+                        }
+                      }
+                    }, _callee2);
+                  }));
+                  return function (_x5) {
+                    return _ref2.apply(this, arguments);
+                  };
+                }())["catch"](function (e) {
+                  sprCache.del(cacheContext, cacheHash);
+                  ctx.error(ERROR_DIGEST.ERENDER, e);
+                });
+              }
+            case 22:
+              ctx.res.setHeader('x-modern-spr', '1');
+              return _context5.abrupt("return", cacheFile.content);
+            case 24:
+            case "end":
+              return _context5.stop();
+          }
+        }
+      }, _callee5);
+    }));
+    return function doRender(_x) {
+      return _ref.apply(this, arguments);
+    };
+  }();
+  return doRender;
+});

package/dist/js/treeshaking/libs/render/cache/page-caches/index.js

@@ -0,0 +1,30 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import { LRUCaches } from "./lru";
+export function createPageCaches(_x) {
+  return _createPageCaches.apply(this, arguments);
+}
+function _createPageCaches() {
+  _createPageCaches = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(max) {
+    var constructorOptions, cacheInstance;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            constructorOptions = {
+              max: max
+            };
+            cacheInstance = new LRUCaches(constructorOptions);
+            _context.next = 4;
+            return cacheInstance.init();
+          case 4:
+            return _context.abrupt("return", cacheInstance);
+          case 5:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  }));
+  return _createPageCaches.apply(this, arguments);
+}

package/dist/js/treeshaking/libs/render/cache/page-caches/lru.js

@@ -0,0 +1,46 @@
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+import LRU from 'lru-cache';
+export var LRUCaches = /*#__PURE__*/function () {
+  function LRUCaches(options) {
+    _classCallCheck(this, LRUCaches);
+    _defineProperty(this, "caches", void 0);
+    _defineProperty(this, "max", void 0);
+    this.max = options.max;
+    this.caches = new LRU(this.max);
+  }
+  _createClass(LRUCaches, [{
+    key: "init",
+    value: function init() {
+      return Promise.resolve();
+    }
+  }, {
+    key: "keys",
+    value: function keys() {
+      return this.caches.keys();
+    }
+  }, {
+    key: "get",
+    value: function get(key) {
+      return Promise.resolve(this.caches.get(key) || null);
+    }
+  }, {
+    key: "peek",
+    value: function peek(key) {
+      return this.caches.peek(key) || null;
+    }
+  }, {
+    key: "set",
+    value: function set(key, cache) {
+      this.caches.set(key, cache);
+      return Promise.resolve();
+    }
+  }, {
+    key: "del",
+    value: function del(key) {
+      this.caches.del(key);
+    }
+  }]);
+  return LRUCaches;
+}();

package/dist/js/treeshaking/libs/render/cache/spr.js

@@ -0,0 +1,362 @@
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _classCallCheck from "@babel/runtime/helpers/esm/classCallCheck";
+import _createClass from "@babel/runtime/helpers/esm/createClass";
+import _defineProperty from "@babel/runtime/helpers/esm/defineProperty";
+/* eslint-disable @typescript-eslint/member-ordering */
+/* eslint-disable no-lone-blocks */
+import crypto from 'crypto';
+import LRUCache from 'lru-cache';
+import { mime } from '@modern-js/utils';
+import { cacheAddition, connectFactor, fname, maybeSync, namespaceHash, valueFactory, withCoalescedInvoke } from "./util";
+import { createPageCaches } from "./page-caches";
+var MAX_CACHE_EACH_REQ = Number(process.env.ROUTE_CACHE_LIMIT) || 10;
+var MAX_SIZE_EACH_CLUSTER = Number(process.env.CLUSTER_CACHE_LIMIT) || 100;
+var BASE_LEVEL = 0;
+var QUERY_LEVEL = 1;
+var HEADER_LEVEL = 2;
+var QUERY_HEADER_LEVEL = 3;
+var CacheManager = /*#__PURE__*/function () {
+  function CacheManager(cacheOptions) {
+    var _this2 = this;
+    _classCallCheck(this, CacheManager);
+    _defineProperty(this, "cache", void 0);
+    _defineProperty(this, "cacheOptions", void 0);
+    _defineProperty(this, "find", function () {
+      {
+        var _ref;
+        // eslint-disable-next-line consistent-this,@typescript-eslint/no-this-alias
+        var _this = _this2;
+        return _ref = {}, _defineProperty(_ref, fname(BASE_LEVEL), function (context, cacheKey
+        // data: CacheContent,
+        ) {
+          return _this.md5(cacheKey);
+        }), _defineProperty(_ref, fname(QUERY_LEVEL), function (context, cacheKey, data) {
+          var queryFactor = _this.queryFactor(context, data);
+          if (!queryFactor) {
+            return null;
+          }
+          return _this.md5(connectFactor(cacheKey, queryFactor));
+        }), _defineProperty(_ref, fname(HEADER_LEVEL), function (context, cacheKey, data) {
+          var headerFactor = _this.headerFactor(context, data);
+          if (!headerFactor) {
+            return null;
+          }
+          return _this.md5(connectFactor(cacheKey, headerFactor));
+        }), _defineProperty(_ref, fname(QUERY_HEADER_LEVEL), function (context, cacheKey, data) {
+          var queryFactor = _this.queryFactor(context, data);
+          var headerFactor = _this.headerFactor(context, data);
+          if (!queryFactor || !headerFactor) {
+            return null;
+          }
+          return _this.md5(connectFactor(cacheKey, headerFactor, queryFactor));
+        }), _ref;
+      }
+    }());
+    this.cacheOptions = cacheOptions;
+    this.cache = new LRUCache({
+      max: Math.min(MAX_SIZE_EACH_CLUSTER, 600) * 1024 * 1024,
+      // 默认存 100M，最大 600M
+      length: function length(n) {
+        var len = n.caches.keys().reduce(function (total, cur) {
+          var _n$caches$peek;
+          return total + (((_n$caches$peek = n.caches.peek(cur)) === null || _n$caches$peek === void 0 ? void 0 : _n$caches$peek.size) || 0);
+        }, 1);
+        return len;
+      }
+    });
+  }
+  _createClass(CacheManager, [{
+    key: "md5",
+    value: function md5(content) {
+      var md5 = crypto.createHash('md5');
+      return md5.update(content).digest('hex');
+    }
+  }, {
+    key: "generateRequestKey",
+    value: function generateRequestKey(context) {
+      var pathname = context.pathname,
+        entry = context.entry;
+      return this.md5("".concat(pathname, "_").concat(entry));
+    }
+  }, {
+    key: "replaceValue",
+    value: function replaceValue(value, matcher) {
+      var _final = value;
+      Object.keys(matcher).some(function (replacer) {
+        var reg = new RegExp(matcher[replacer]);
+        if (reg.test(value)) {
+          _final = replacer;
+          return true;
+        }
+        return false;
+      });
+      return _final;
+    }
+  }, {
+    key: "factor",
+    value: function factor(keys, obj) {
+      var _this3 = this;
+      var matches = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      keys.sort();
+      var getValue = valueFactory(obj);
+      var factorAry = keys.reduce(function (ary, key) {
+        var value = getValue(key) || '';
+        var matcher = matches[key];
+        if (matcher) {
+          value = _this3.replaceValue(value, matcher);
+        }
+        return ary.concat([key, value]);
+      }, []);
+      return factorAry.join(',');
+    }
+  }, {
+    key: "queryFactor",
+    value: function queryFactor(context, data) {
+      var _data$includes, _data$matches;
+      var queryKeys = (_data$includes = data.includes) === null || _data$includes === void 0 ? void 0 : _data$includes.query;
+      var queryMatches = (_data$matches = data.matches) === null || _data$matches === void 0 ? void 0 : _data$matches.query;
+      if (!queryKeys || queryKeys.length === 0) {
+        return null;
+      }
+      var requestQuery = context.query;
+      var queryFactor = this.factor(queryKeys, requestQuery, queryMatches);
+      return queryFactor;
+    }
+  }, {
+    key: "headerFactor",
+    value: function headerFactor(context, data) {
+      var _data$includes2, _data$matches2;
+      var headerKeys = (_data$includes2 = data.includes) === null || _data$includes2 === void 0 ? void 0 : _data$includes2.header;
+      var headerMatches = (_data$matches2 = data.matches) === null || _data$matches2 === void 0 ? void 0 : _data$matches2.header;
+      if (!headerKeys || headerKeys.length === 0) {
+        return null;
+      }
+      var requestHeader = context.headers;
+      var headerFactor = this.factor(headerKeys, requestHeader, headerMatches);
+      return headerFactor;
+    }
+  }, {
+    key: "best",
+    value: function () {
+      var _best = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee(context, cacheKey, data) {
+        var level, cacheHash;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) {
+            switch (_context.prev = _context.next) {
+              case 0:
+                level = data.level;
+                cacheHash = this.find[fname(level)](context, cacheKey, data);
+                if (cacheHash) {
+                  _context.next = 4;
+                  break;
+                }
+                return _context.abrupt("return", null);
+              case 4:
+                return _context.abrupt("return", data.caches.get(cacheHash));
+              case 5:
+              case "end":
+                return _context.stop();
+            }
+          }
+        }, _callee, this);
+      }));
+      function best(_x, _x2, _x3) {
+        return _best.apply(this, arguments);
+      }
+      return best;
+    }()
+  }, {
+    key: "createCacheContent",
+    value: function createCacheContent(config, caches) {
+      return {
+        level: config.level,
+        interval: config.interval,
+        includes: config.includes || null,
+        limit: config.staleLimit,
+        matches: config.matches || null,
+        caches: caches
+      };
+    }
+  }, {
+    key: "get",
+    value: function () {
+      var _get = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2(context) {
+        var cacheKey, data, dest, expireTime, limitTime, html, cacheHash, isStale, isGarbage;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) {
+            switch (_context2.prev = _context2.next) {
+              case 0:
+                cacheKey = this.generateRequestKey(context);
+                data = this.cache.get(cacheKey); // no cache key matched
+                if (data) {
+                  _context2.next = 4;
+                  break;
+                }
+                return _context2.abrupt("return", null);
+              case 4:
+                _context2.next = 6;
+                return this.best(context, cacheKey, data);
+              case 6:
+                dest = _context2.sent;
+                if (dest) {
+                  _context2.next = 9;
+                  break;
+                }
+                return _context2.abrupt("return", null);
+              case 9:
+                expireTime = dest.expireTime, limitTime = dest.limitTime, html = dest.html, cacheHash = dest.cacheHash;
+                isStale = Date.now() - expireTime > 0;
+                isGarbage = limitTime ? Date.now() - limitTime > 0 : false;
+                return _context2.abrupt("return", {
+                  content: html || '',
+                  contentType: mime.contentType('html'),
+                  isStale: isStale,
+                  isGarbage: isGarbage,
+                  hash: cacheHash
+                });
+              case 13:
+              case "end":
+                return _context2.stop();
+            }
+          }
+        }, _callee2, this);
+      }));
+      function get(_x4) {
+        return _get.apply(this, arguments);
+      }
+      return get;
+    }()
+  }, {
+    key: "set",
+    value: function () {
+      var _set = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4(context, html, cacheConfig) {
+        var _this4 = this;
+        var sync,
+          cacheKey,
+          data,
+          caches,
+          cacheHash,
+          cacheSyncOrAsync,
+          doCache,
+          _args4 = arguments;
+        return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+          while (1) {
+            switch (_context4.prev = _context4.next) {
+              case 0:
+                sync = _args4.length > 3 && _args4[3] !== undefined ? _args4[3] : false;
+                if (cacheConfig) {
+                  _context4.next = 3;
+                  break;
+                }
+                return _context4.abrupt("return", false);
+              case 3:
+                // each version with route is a separate cache
+                cacheKey = this.generateRequestKey(context);
+                data = this.cache.get(cacheKey);
+                if (data) {
+                  _context4.next = 10;
+                  break;
+                }
+                _context4.next = 8;
+                return createPageCaches(MAX_CACHE_EACH_REQ);
+              case 8:
+                caches = _context4.sent;
+                data = this.createCacheContent(cacheConfig, caches);
+              case 10:
+                cacheHash = this.find[fname(cacheConfig.level)](context, cacheKey, data); // if cacheHash is null, maybe level not match meta key, do not cache
+                if (cacheHash) {
+                  _context4.next = 13;
+                  break;
+                }
+                return _context4.abrupt("return", false);
+              case 13:
+                cacheSyncOrAsync = /*#__PURE__*/function () {
+                  var _ref2 = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+                    var next, limit, storeHTML, size;
+                    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+                      while (1) {
+                        switch (_context3.prev = _context3.next) {
+                          case 0:
+                            next = data;
+                            limit = cacheConfig.staleLimit;
+                            storeHTML = cacheAddition(html, cacheHash);
+                            size = storeHTML.length;
+                            _context3.next = 6;
+                            return next.caches.set(cacheHash, {
+                              expireTime: Date.now() + cacheConfig.interval * 1000,
+                              limitTime: typeof limit === 'number' ? Date.now() + limit * 1000 : null,
+                              cacheHash: cacheHash,
+                              html: storeHTML,
+                              size: size
+                            });
+                          case 6:
+                            _this4.cache.set(cacheKey, next);
+                            return _context3.abrupt("return", true);
+                          case 8:
+                          case "end":
+                            return _context3.stop();
+                        }
+                      }
+                    }, _callee3);
+                  }));
+                  return function cacheSyncOrAsync() {
+                    return _ref2.apply(this, arguments);
+                  };
+                }(); // cache set is async, each hash is cached only once at the same time
+                doCache = withCoalescedInvoke(cacheSyncOrAsync).bind(null, namespaceHash('stream', cacheHash), []);
+                return _context4.abrupt("return", maybeSync(doCache)(sync));
+              case 16:
+              case "end":
+                return _context4.stop();
+            }
+          }
+        }, _callee4, this);
+      }));
+      function set(_x5, _x6, _x7) {
+        return _set.apply(this, arguments);
+      }
+      return set;
+    }()
+  }, {
+    key: "del",
+    value: function () {
+      var _del = _asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5(context, cacheHash) {
+        var cacheKey, data;
+        return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+          while (1) {
+            switch (_context5.prev = _context5.next) {
+              case 0:
+                cacheKey = this.generateRequestKey(context);
+                data = this.cache.get(cacheKey);
+                data === null || data === void 0 ? void 0 : data.caches.del(cacheHash);
+              case 3:
+              case "end":
+                return _context5.stop();
+            }
+          }
+        }, _callee5, this);
+      }));
+      function del(_x8, _x9) {
+        return _del.apply(this, arguments);
+      }
+      return del;
+    }()
+  }]);
+  return CacheManager;
+}();
+var manager;
+export function createCache() {
+  if (manager) {
+    return manager;
+  }
+  manager = new CacheManager({
+    max: 0
+  });
+  return manager;
+}
+export function destroyCache() {
+  manager = null;
+}
+/* eslint-enable no-lone-blocks */
+/* eslint-enable @typescript-eslint/member-ordering */

package/dist/js/treeshaking/libs/render/cache/type.js

@@ -0,0 +1 @@
+export {};