@modern-js/prod-server 1.0.1

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

@@ -0,0 +1,233 @@
+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 { createCache, destroyCache } from "../spr";
+import { errorConfiguration } from "./error-configuration";
+import { cacheabelAry } from "./cacheable";
+import { matchedCacheableAry } from "./matched-cache";
+
+const createCacheConfig = (config = {}) => _objectSpread({
+  excludes: null,
+  includes: null,
+  interval: 10,
+  staleLimit: false,
+  level: 0,
+  fallback: false,
+  matches: null
+}, config);
+
+jest.setTimeout(60000);
+describe('cache', () => {
+  it('should cache correctly', async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: '',
+      pathname: '',
+      query: {},
+      headers: {}
+    };
+    const content = 'hello';
+    const cacheConfig = createCacheConfig();
+    await cache.set(context, content, cacheConfig, true);
+    const cacheResult = await cache.get(context);
+    expect(cacheResult).not.toBe(null);
+    expect(cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.content).toBe('hello');
+  });
+  it('should ignore cache set when cache config not exist', async () => {
+    destroyCache();
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: '',
+      pathname: '',
+      query: {},
+      headers: {}
+    };
+    const content = 'hello';
+    const shouldCache = await cache.set(context, content, null, true);
+    expect(shouldCache).toBe(false);
+  });
+  it('should calcual cache key error', async () => {
+    destroyCache();
+    const cache = createCache();
+    const content = 'hello';
+
+    for (const config of errorConfiguration) {
+      const cacheConfig = createCacheConfig(config);
+      const tmpEntry = Math.random().toString();
+      const context = {
+        entry: tmpEntry,
+        pathname: '',
+        query: {},
+        headers: {}
+      };
+      const shouldCache = await cache.set(context, content, cacheConfig);
+      expect(shouldCache).toBe(false);
+    }
+  });
+  it('should get nothing for diff requestKey', async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: '',
+      pathname: '',
+      query: {},
+      headers: {}
+    };
+    const content = 'hello';
+    const cacheConfig = createCacheConfig({
+      level: 1,
+      includes: {
+        query: ['name']
+      }
+    });
+    await cache.set(context, content, cacheConfig, true);
+    const context_req = {
+      entry: '',
+      pathname: '/home',
+      query: {},
+      headers: {}
+    };
+    const cacheResult = await cache.get(context_req);
+    expect(cacheResult).toBe(null);
+  });
+  it('should get nothing for diff cacheHash', async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: '',
+      pathname: '',
+      query: {},
+      headers: {}
+    };
+    const content = 'hello';
+    const cacheConfig = createCacheConfig({
+      level: 1,
+      includes: {
+        query: ['name']
+      }
+    });
+    await cache.set(context, content, cacheConfig, true);
+    const context_req = {
+      entry: '',
+      pathname: '',
+      query: {
+        name: 'zll'
+      },
+      headers: {}
+    };
+    const cacheResult = await cache.get(context_req);
+    expect(cacheResult).toBe(null);
+  });
+  it('should get cache correctly', async () => {
+    destroyCache();
+    const cache = createCache();
+
+    for (const cacheable of cacheabelAry) {
+      const context = {
+        entry: '',
+        pathname: cacheable.requestOpt.url,
+        query: cacheable.requestOpt.query || {},
+        headers: cacheable.requestOpt.headers || {}
+      };
+      const cacheConfig = createCacheConfig(cacheable.cacheConfig || {});
+      await cache.set(context, cacheable.content, cacheConfig, true);
+      const cacheResult = await cache.get(context);
+      expect(cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.content).toBe(cacheable.content);
+    }
+  });
+  it('should match cache correctly', async () => {
+    destroyCache();
+    const cache = createCache();
+
+    for (const cacheable of matchedCacheableAry) {
+      const [baseCacheable, matchOne, ...other] = cacheable;
+      const {
+        requestOpt = {},
+        cacheConfig,
+        content
+      } = baseCacheable;
+      const context = {
+        entry: '',
+        pathname: requestOpt.url,
+        query: requestOpt.query,
+        headers: requestOpt.headers
+      };
+      await cache.set(context, content, createCacheConfig(cacheConfig), true);
+      const matchContext = {
+        entry: '',
+        pathname: matchOne.url,
+        query: matchOne.query,
+        headers: matchOne.headers
+      };
+      const cacheResult = await cache.get(matchContext);
+      expect(cacheResult === null || cacheResult === void 0 ? void 0 : cacheResult.content).toBe(content);
+
+      for (const notMatch of other) {
+        const notMatchContext = {
+          entry: '',
+          pathname: notMatch.url,
+          query: notMatch.query,
+          headers: notMatch.headers
+        };
+        const nothing = await cache.get(notMatchContext);
+        expect(nothing).toBe(null);
+      }
+    }
+  });
+  it('should stale cache correctly', async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: '',
+      pathname: '',
+      query: {},
+      headers: {}
+    };
+    const config = createCacheConfig({
+      interval: 5
+    });
+    const content = 'hello';
+    const shouldCache = await cache.set(context, content, config, true);
+    expect(shouldCache.value).toBe(true);
+    const freshResult = await cache.get(context);
+    expect(freshResult === null || freshResult === void 0 ? void 0 : freshResult.isStale).toBe(false);
+    await new Promise(resolve => {
+      setTimeout(() => {
+        resolve();
+      }, 6000);
+    });
+    const staleResult = await cache.get(context);
+    expect(staleResult === null || staleResult === void 0 ? void 0 : staleResult.isStale).toBe(true);
+  });
+  it('should garbage cache correctly', async () => {
+    destroyCache();
+    const cache = createCache();
+    const context = {
+      entry: '',
+      pathname: '',
+      query: {},
+      headers: {}
+    };
+    const config = createCacheConfig({
+      interval: 3,
+      staleLimit: 8
+    });
+    const content = 'hello';
+    const shouldCache = await cache.set(context, content, config, true);
+    expect(shouldCache.value).toBe(true);
+    const freshResult = await cache.get(context);
+    expect(freshResult === null || freshResult === void 0 ? void 0 : freshResult.isGarbage).toBe(false);
+    await new Promise(resolve => {
+      setTimeout(() => {
+        resolve();
+      }, 10000);
+    });
+    const staleResult = await cache.get(context);
+    expect(staleResult === null || staleResult === void 0 ? void 0 : staleResult.isGarbage).toBe(true);
+  });
+});

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

@@ -0,0 +1,53 @@
+export const 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/modern/libs/render/cache/__tests__/error-configuration.js

@@ -0,0 +1,35 @@
+export const 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/modern/libs/render/cache/__tests__/matched-cache.js

@@ -0,0 +1,121 @@
+export const 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'
+  }
+}]];

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

@@ -0,0 +1,74 @@
+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 { ERROR_DIGEST } from "../../../constants";
+import { createCache } from "./spr";
+import { namespaceHash, withCoalescedInvoke } from "./util";
+export default ((renderFn, ctx) => {
+  const sprCache = createCache();
+
+  const doRender = async context => {
+    const cacheContext = _objectSpread({
+      entry: context.entryName
+    }, context.request);
+
+    const cacheFile = await sprCache.get(cacheContext); // no cache, render sync
+
+    if (!cacheFile) {
+      const html = await renderFn(context);
+      const {
+        cacheConfig
+      } = context;
+
+      if (html && cacheConfig) {
+        await sprCache.set(cacheContext, html, cacheConfig);
+      }
+
+      return html;
+    }
+
+    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;
+    } else if (cacheFile.isStale) {
+      // if file is stale, request async
+      const render = withCoalescedInvoke(() => renderFn(context)).bind(null, namespaceHash('render', cacheFile.hash), []);
+      render() // eslint-disable-next-line promise/prefer-await-to-then
+      .then(res => {
+        if (res.value && res.isOrigin) {
+          const {
+            cacheConfig
+          } = context;
+
+          if (cacheConfig) {
+            sprCache.set(cacheContext, res.value, cacheConfig);
+          } else {
+            sprCache.del(cacheContext, cacheHash);
+          }
+        }
+      }) // eslint-disable-next-line promise/prefer-await-to-then
+      .catch(e => {
+        sprCache.del(cacheContext, cacheHash);
+        ctx.error(ERROR_DIGEST.ERENDER, e);
+      });
+    }
+
+    ctx.res.setHeader('x-modern-spr', '1');
+    return cacheFile.content;
+  };
+
+  return doRender;
+});

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

@@ -0,0 +1,9 @@
+import { LRUCaches } from "./lru";
+export async function createPageCaches(max) {
+  const constructorOptions = {
+    max
+  };
+  const cacheInstance = new LRUCaches(constructorOptions);
+  await cacheInstance.init();
+  return cacheInstance;
+}

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

@@ -0,0 +1,35 @@
+import LRU from 'lru-cache';
+export class LRUCaches {
+  constructor(options) {
+    this.caches = void 0;
+    this.max = void 0;
+    this.max = options.max;
+    this.caches = new LRU(this.max);
+  }
+
+  init() {
+    return Promise.resolve();
+  }
+
+  keys() {
+    return this.caches.keys();
+  }
+
+  get(key) {
+    return Promise.resolve(this.caches.get(key) || null);
+  }
+
+  peek(key) {
+    return this.caches.peek(key) || null;
+  }
+
+  set(key, cache) {
+    this.caches.set(key, cache);
+    return Promise.resolve();
+  }
+
+  del(key) {
+    this.caches.del(key);
+  }
+
+}