@modern-js/prod-server 1.21.5 → 2.0.0-beta.1

package/dist/js/treeshaking/libs/render/cache/__tests__/cache.test.js

@@ -0,0 +1,464 @@
+import _toArray from "@babel/runtime/helpers/esm/toArray";
+import _createForOfIteratorHelper from "@babel/runtime/helpers/esm/createForOfIteratorHelper";
+import _regeneratorRuntime from "@babel/runtime/helpers/esm/regeneratorRuntime";
+import _asyncToGenerator from "@babel/runtime/helpers/esm/asyncToGenerator";
+import _objectSpread from "@babel/runtime/helpers/esm/objectSpread2";
+import { createCache, destroyCache } from "../spr";
+import { errorConfiguration } from "./error-configuration";
+import { cacheabelAry } from "./cacheable";
+import { matchedCacheableAry } from "./matched-cache";
+var createCacheConfig = function createCacheConfig() {
+  var config = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+  return _objectSpread({
+    excludes: null,
+    includes: null,
+    interval: 10,
+    staleLimit: false,
+    level: 0,
+    fallback: false,
+    matches: null
+  }, config);
+};
+jest.setTimeout(60000);
+describe('cache', function () {
+  it('should cache correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+    var cache, context, content, cacheConfig, cacheResult;
+    return _regeneratorRuntime().wrap(function _callee$(_context) {
+      while (1) {
+        switch (_context.prev = _context.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            context = {
+              entry: '',
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            content = 'hello';
+            cacheConfig = createCacheConfig();
+            _context.next = 7;
+            return cache.set(context, content, cacheConfig, true);
+          case 7:
+            _context.next = 9;
+            return cache.get(context);
+          case 9:
+            cacheResult = _context.sent;
+            expect(cacheResult).not.toBe(null);
+            expect(cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.content).toBe('hello');
+          case 12:
+          case "end":
+            return _context.stop();
+        }
+      }
+    }, _callee);
+  })));
+  it('should ignore cache set when cache config not exist', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee2() {
+    var cache, context, content, shouldCache;
+    return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+      while (1) {
+        switch (_context2.prev = _context2.next) {
+          case 0:
+            destroyCache();
+            destroyCache();
+            cache = createCache();
+            context = {
+              entry: '',
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            content = 'hello';
+            _context2.next = 7;
+            return cache.set(context, content, null, true);
+          case 7:
+            shouldCache = _context2.sent;
+            expect(shouldCache).toBe(false);
+          case 9:
+          case "end":
+            return _context2.stop();
+        }
+      }
+    }, _callee2);
+  })));
+  it('should calcual cache key error', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee3() {
+    var cache, content, _iterator, _step, config, cacheConfig, tmpEntry, context, shouldCache;
+    return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+      while (1) {
+        switch (_context3.prev = _context3.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            content = 'hello';
+            _iterator = _createForOfIteratorHelper(errorConfiguration);
+            _context3.prev = 4;
+            _iterator.s();
+          case 6:
+            if ((_step = _iterator.n()).done) {
+              _context3.next = 17;
+              break;
+            }
+            config = _step.value;
+            cacheConfig = createCacheConfig(config);
+            tmpEntry = Math.random().toString();
+            context = {
+              entry: tmpEntry,
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            _context3.next = 13;
+            return cache.set(context, content, cacheConfig);
+          case 13:
+            shouldCache = _context3.sent;
+            expect(shouldCache).toBe(false);
+          case 15:
+            _context3.next = 6;
+            break;
+          case 17:
+            _context3.next = 22;
+            break;
+          case 19:
+            _context3.prev = 19;
+            _context3.t0 = _context3["catch"](4);
+            _iterator.e(_context3.t0);
+          case 22:
+            _context3.prev = 22;
+            _iterator.f();
+            return _context3.finish(22);
+          case 25:
+          case "end":
+            return _context3.stop();
+        }
+      }
+    }, _callee3, null, [[4, 19, 22, 25]]);
+  })));
+  it('should get nothing for diff requestKey', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee4() {
+    var cache, context, content, cacheConfig, context_req, cacheResult;
+    return _regeneratorRuntime().wrap(function _callee4$(_context4) {
+      while (1) {
+        switch (_context4.prev = _context4.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            context = {
+              entry: '',
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            content = 'hello';
+            cacheConfig = createCacheConfig({
+              level: 1,
+              includes: {
+                query: ['name']
+              }
+            });
+            _context4.next = 7;
+            return cache.set(context, content, cacheConfig, true);
+          case 7:
+            context_req = {
+              entry: '',
+              pathname: '/home',
+              query: {},
+              headers: {}
+            };
+            _context4.next = 10;
+            return cache.get(context_req);
+          case 10:
+            cacheResult = _context4.sent;
+            expect(cacheResult).toBe(null);
+          case 12:
+          case "end":
+            return _context4.stop();
+        }
+      }
+    }, _callee4);
+  })));
+  it('should get nothing for diff cacheHash', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee5() {
+    var cache, context, content, cacheConfig, context_req, cacheResult;
+    return _regeneratorRuntime().wrap(function _callee5$(_context5) {
+      while (1) {
+        switch (_context5.prev = _context5.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            context = {
+              entry: '',
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            content = 'hello';
+            cacheConfig = createCacheConfig({
+              level: 1,
+              includes: {
+                query: ['name']
+              }
+            });
+            _context5.next = 7;
+            return cache.set(context, content, cacheConfig, true);
+          case 7:
+            context_req = {
+              entry: '',
+              pathname: '',
+              query: {
+                name: 'zll'
+              },
+              headers: {}
+            };
+            _context5.next = 10;
+            return cache.get(context_req);
+          case 10:
+            cacheResult = _context5.sent;
+            expect(cacheResult).toBe(null);
+          case 12:
+          case "end":
+            return _context5.stop();
+        }
+      }
+    }, _callee5);
+  })));
+  it('should get cache correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee6() {
+    var cache, _iterator2, _step2, cacheable, context, cacheConfig, cacheResult;
+    return _regeneratorRuntime().wrap(function _callee6$(_context6) {
+      while (1) {
+        switch (_context6.prev = _context6.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            _iterator2 = _createForOfIteratorHelper(cacheabelAry);
+            _context6.prev = 3;
+            _iterator2.s();
+          case 5:
+            if ((_step2 = _iterator2.n()).done) {
+              _context6.next = 17;
+              break;
+            }
+            cacheable = _step2.value;
+            context = {
+              entry: '',
+              pathname: cacheable.requestOpt.url,
+              query: cacheable.requestOpt.query || {},
+              headers: cacheable.requestOpt.headers || {}
+            };
+            cacheConfig = createCacheConfig(cacheable.cacheConfig || {});
+            _context6.next = 11;
+            return cache.set(context, cacheable.content, cacheConfig, true);
+          case 11:
+            _context6.next = 13;
+            return cache.get(context);
+          case 13:
+            cacheResult = _context6.sent;
+            expect(cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.content).toBe(cacheable.content);
+          case 15:
+            _context6.next = 5;
+            break;
+          case 17:
+            _context6.next = 22;
+            break;
+          case 19:
+            _context6.prev = 19;
+            _context6.t0 = _context6["catch"](3);
+            _iterator2.e(_context6.t0);
+          case 22:
+            _context6.prev = 22;
+            _iterator2.f();
+            return _context6.finish(22);
+          case 25:
+          case "end":
+            return _context6.stop();
+        }
+      }
+    }, _callee6, null, [[3, 19, 22, 25]]);
+  })));
+  it('should match cache correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee7() {
+    var cache, _iterator3, _step3, _cacheResult, cacheable, _cacheable, baseCacheable, matchOne, other, _baseCacheable$reques, requestOpt, cacheConfig, content, context, matchContext, cacheResult, _iterator4, _step4, notMatch, notMatchContext, nothing;
+    return _regeneratorRuntime().wrap(function _callee7$(_context7) {
+      while (1) {
+        switch (_context7.prev = _context7.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            _iterator3 = _createForOfIteratorHelper(matchedCacheableAry);
+            _context7.prev = 3;
+            _iterator3.s();
+          case 5:
+            if ((_step3 = _iterator3.n()).done) {
+              _context7.next = 39;
+              break;
+            }
+            cacheable = _step3.value;
+            _cacheable = _toArray(cacheable), baseCacheable = _cacheable[0], matchOne = _cacheable[1], other = _cacheable.slice(2);
+            _baseCacheable$reques = baseCacheable.requestOpt, requestOpt = _baseCacheable$reques === void 0 ? {} : _baseCacheable$reques, cacheConfig = baseCacheable.cacheConfig, content = baseCacheable.content;
+            context = {
+              entry: '',
+              pathname: requestOpt.url,
+              query: requestOpt.query,
+              headers: requestOpt.headers
+            };
+            _context7.next = 12;
+            return cache.set(context, content, createCacheConfig(cacheConfig), true);
+          case 12:
+            matchContext = {
+              entry: '',
+              pathname: matchOne.url,
+              query: matchOne.query,
+              headers: matchOne.headers
+            };
+            _context7.next = 15;
+            return cache.get(matchContext);
+          case 15:
+            cacheResult = _context7.sent;
+            expect((_cacheResult = cacheResult) === null || _cacheResult === void 0 ? void 0 : _cacheResult.content).toBe(content);
+            _iterator4 = _createForOfIteratorHelper(other);
+            _context7.prev = 18;
+            _iterator4.s();
+          case 20:
+            if ((_step4 = _iterator4.n()).done) {
+              _context7.next = 29;
+              break;
+            }
+            notMatch = _step4.value;
+            notMatchContext = {
+              entry: '',
+              pathname: notMatch.url,
+              query: notMatch.query,
+              headers: notMatch.headers
+            };
+            _context7.next = 25;
+            return cache.get(notMatchContext);
+          case 25:
+            nothing = _context7.sent;
+            expect(nothing).toBe(null);
+          case 27:
+            _context7.next = 20;
+            break;
+          case 29:
+            _context7.next = 34;
+            break;
+          case 31:
+            _context7.prev = 31;
+            _context7.t0 = _context7["catch"](18);
+            _iterator4.e(_context7.t0);
+          case 34:
+            _context7.prev = 34;
+            _iterator4.f();
+            return _context7.finish(34);
+          case 37:
+            _context7.next = 5;
+            break;
+          case 39:
+            _context7.next = 44;
+            break;
+          case 41:
+            _context7.prev = 41;
+            _context7.t1 = _context7["catch"](3);
+            _iterator3.e(_context7.t1);
+          case 44:
+            _context7.prev = 44;
+            _iterator3.f();
+            return _context7.finish(44);
+          case 47:
+          case "end":
+            return _context7.stop();
+        }
+      }
+    }, _callee7, null, [[3, 41, 44, 47], [18, 31, 34, 37]]);
+  })));
+  it('should stale cache correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee8() {
+    var cache, context, config, content, shouldCache, freshResult, staleResult;
+    return _regeneratorRuntime().wrap(function _callee8$(_context8) {
+      while (1) {
+        switch (_context8.prev = _context8.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            context = {
+              entry: '',
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            config = createCacheConfig({
+              interval: 5
+            });
+            content = 'hello';
+            _context8.next = 7;
+            return cache.set(context, content, config, true);
+          case 7:
+            shouldCache = _context8.sent;
+            expect(shouldCache.value).toBe(true);
+            _context8.next = 11;
+            return cache.get(context);
+          case 11:
+            freshResult = _context8.sent;
+            expect(freshResult === null || freshResult === void 0 ? void 0 : freshResult.isStale).toBe(false);
+            _context8.next = 15;
+            return new Promise(function (resolve) {
+              setTimeout(function () {
+                resolve();
+              }, 6000);
+            });
+          case 15:
+            _context8.next = 17;
+            return cache.get(context);
+          case 17:
+            staleResult = _context8.sent;
+            expect(staleResult === null || staleResult === void 0 ? void 0 : staleResult.isStale).toBe(true);
+          case 19:
+          case "end":
+            return _context8.stop();
+        }
+      }
+    }, _callee8);
+  })));
+  it('should garbage cache correctly', /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/_regeneratorRuntime().mark(function _callee9() {
+    var cache, context, config, content, shouldCache, freshResult, staleResult;
+    return _regeneratorRuntime().wrap(function _callee9$(_context9) {
+      while (1) {
+        switch (_context9.prev = _context9.next) {
+          case 0:
+            destroyCache();
+            cache = createCache();
+            context = {
+              entry: '',
+              pathname: '',
+              query: {},
+              headers: {}
+            };
+            config = createCacheConfig({
+              interval: 3,
+              staleLimit: 8
+            });
+            content = 'hello';
+            _context9.next = 7;
+            return cache.set(context, content, config, true);
+          case 7:
+            shouldCache = _context9.sent;
+            expect(shouldCache.value).toBe(true);
+            _context9.next = 11;
+            return cache.get(context);
+          case 11:
+            freshResult = _context9.sent;
+            expect(freshResult === null || freshResult === void 0 ? void 0 : freshResult.isGarbage).toBe(false);
+            _context9.next = 15;
+            return new Promise(function (resolve) {
+              setTimeout(function () {
+                resolve();
+              }, 10000);
+            });
+          case 15:
+            _context9.next = 17;
+            return cache.get(context);
+          case 17:
+            staleResult = _context9.sent;
+            expect(staleResult === null || staleResult === void 0 ? void 0 : staleResult.isGarbage).toBe(true);
+          case 19:
+          case "end":
+            return _context9.stop();
+        }
+      }
+    }, _callee9);
+  })));
+});

package/dist/js/treeshaking/libs/render/cache/__tests__/cacheable.js

@@ -0,0 +1,53 @@
+export var cacheabelAry = [{
+  requestOpt: {
+    url: '/'
+  },
+  cacheConfig: {},
+  content: 'level0'
+}, {
+  requestOpt: {
+    url: '/level-one',
+    query: {
+      name: 'modern'
+    }
+  },
+  cacheConfig: {
+    level: 1,
+    includes: {
+      query: ['name']
+    }
+  },
+  content: 'level1'
+}, {
+  requestOpt: {
+    url: '/level-two',
+    headers: {
+      age: '18'
+    }
+  },
+  cacheConfig: {
+    level: 2,
+    includes: {
+      header: ['age']
+    }
+  },
+  content: 'level2'
+}, {
+  requestOpt: {
+    url: '/level-three',
+    query: {
+      name: 'modern'
+    },
+    headers: {
+      age: '18'
+    }
+  },
+  cacheConfig: {
+    level: 3,
+    includes: {
+      query: ['name'],
+      header: ['age']
+    }
+  },
+  content: 'level3'
+}];

package/dist/js/treeshaking/libs/render/cache/__tests__/error-configuration.js

@@ -0,0 +1,35 @@
+export var errorConfiguration = [{
+  level: 1
+}, {
+  level: 1,
+  includes: {}
+}, {
+  level: 1,
+  includes: {
+    query: []
+  }
+}, {
+  level: 2,
+  includes: {}
+}, {
+  level: 2,
+  includes: {
+    header: []
+  }
+}, {
+  level: 3,
+  includes: {
+    header: []
+  }
+}, {
+  level: 3,
+  includes: {
+    query: []
+  }
+}, {
+  level: 3,
+  includes: {
+    query: [],
+    header: []
+  }
+}];

package/dist/js/treeshaking/libs/render/cache/__tests__/matched-cache.js

@@ -0,0 +1,121 @@
+export var matchedCacheableAry = [[{
+  requestOpt: {
+    url: '/level-one',
+    headers: {},
+    query: {
+      name: 'byted'
+    }
+  },
+  cacheConfig: {
+    level: 1,
+    includes: {
+      query: ['name']
+    },
+    matches: {
+      query: {
+        name: {
+          weixin: '^byted'
+        }
+      }
+    }
+  },
+  content: 'level1'
+}, {
+  url: '/level-one',
+  headers: {},
+  query: {
+    name: 'byted_likely'
+  }
+}, {
+  url: '/level-one',
+  headers: {},
+  query: {
+    name: 'not_byted'
+  }
+}], [{
+  requestOpt: {
+    url: '/level-two',
+    query: {},
+    headers: {
+      age: '17'
+    }
+  },
+  cacheConfig: {
+    level: 2,
+    includes: {
+      header: ['age']
+    },
+    matches: {
+      header: {
+        age: {
+          one: '^1'
+        }
+      }
+    }
+  },
+  content: 'level2'
+}, {
+  url: '/level-two',
+  query: {},
+  headers: {
+    age: '11'
+  }
+}, {
+  url: '/level-two',
+  query: {},
+  headers: {
+    age: '22'
+  }
+}], [{
+  requestOpt: {
+    url: '/level-three',
+    headers: {
+      age: '17'
+    },
+    query: {
+      name: 'byted'
+    }
+  },
+  cacheConfig: {
+    level: 3,
+    includes: {
+      query: ['name'],
+      header: ['age']
+    },
+    matches: {
+      query: {
+        name: {
+          weixin: '^byted'
+        }
+      },
+      header: {
+        age: {
+          one: '^1'
+        }
+      }
+    }
+  },
+  content: 'level3'
+}, {
+  url: '/level-three',
+  query: {
+    name: 'byted_likely'
+  },
+  headers: {
+    age: '19'
+  }
+}, {
+  url: '/level-three',
+  query: {
+    name: 'byted_likely'
+  },
+  headers: {}
+}, {
+  url: '/level-three',
+  query: {
+    name: 'not_byted'
+  },
+  headers: {
+    age: '19'
+  }
+}]];