@modern-js/server 1.3.1 → 1.3.2

package/src/libs/render/cache/__tests__/cache.test.ts

@@ -1,240 +0,0 @@
-import { createCache, destroyCache } from '../spr';
-import { CacheContext } from '../type';
-import { errorConfiguration } from './error-configuration';
-import { cacheabelAry } from './cacheable';
-import { matchedCacheableAry } from './matched-cache';
-
-const createCacheConfig = (config: any = {}) => ({
-  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: CacheContext = {
-      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?.content).toBe('hello');
-  });
-
-  it('should ignore cache set when cache config not exist', async () => {
-    destroyCache();
-    destroyCache();
-    const cache = createCache();
-    const context: CacheContext = {
-      entry: '',
-      pathname: '',
-      query: {},
-      headers: {},
-    };
-    const content = 'hello';
-
-    const shouldCache = await cache.set(context, content, null as any, 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: CacheContext = {
-        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: CacheContext = {
-      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: CacheContext = {
-      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: CacheContext = {
-      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: CacheContext = {
-      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: CacheContext = {
-        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?.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 = {} as any, cacheConfig, content } = baseCacheable;
-      const context: CacheContext = {
-        entry: '',
-        pathname: requestOpt.url,
-        query: requestOpt.query,
-        headers: requestOpt.headers,
-      };
-      await cache.set(context, content!, createCacheConfig(cacheConfig), true);
-
-      const matchContext: CacheContext = {
-        entry: '',
-        pathname: matchOne.url!,
-        query: matchOne.query!,
-        headers: matchOne.headers!,
-      };
-      const cacheResult = await cache.get(matchContext);
-      expect(cacheResult?.content).toBe(content);
-
-      for (const notMatch of other) {
-        const notMatchContext: CacheContext = {
-          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: CacheContext = {
-      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?.isStale).toBe(false);
-
-    await new Promise<void>(resolve => {
-      setTimeout(() => {
-        resolve();
-      }, 6000);
-    });
-
-    const staleResult = await cache.get(context);
-    expect(staleResult?.isStale).toBe(true);
-  });
-
-  it('should garbage cache correctly', async () => {
-    destroyCache();
-    const cache = createCache();
-    const context: CacheContext = {
-      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?.isGarbage).toBe(false);
-
-    await new Promise<void>(resolve => {
-      setTimeout(() => {
-        resolve();
-      }, 10000);
-    });
-
-    const staleResult = await cache.get(context);
-    expect(staleResult?.isGarbage).toBe(true);
-  });
-});

package/src/libs/render/cache/__tests__/cacheable.ts

@@ -1,44 +0,0 @@
-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/src/libs/render/cache/__tests__/error-configuration.ts

@@ -1,34 +0,0 @@
-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/src/libs/render/cache/__tests__/matched-cache.ts

@@ -1,88 +0,0 @@
-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/src/libs/render/cache/index.ts

@@ -1,75 +0,0 @@
-import { ModernServerContext } from '../../context';
-import { RenderFunction, SSRServerContext } from '../type';
-import { ERROR_DIGEST } from '../../../constants';
-import { createCache } from './spr';
-import { namespaceHash, withCoalescedInvoke } from './util';
-import { CacheContext } from './type';
-
-export default (renderFn: RenderFunction, ctx: ModernServerContext) => {
-  const sprCache = createCache();
-
-  const doRender: RenderFunction = async (context: SSRServerContext) => {
-    const cacheContext: CacheContext = {
-      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?.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 as string;
-  };
-
-  return doRender;
-};

package/src/libs/render/cache/page-caches/index.ts

@@ -1,11 +0,0 @@
-import { PageCachesInterface } from '../type';
-import { LRUCaches } from './lru';
-
-export async function createPageCaches(
-  max: number,
-): Promise<PageCachesInterface> {
-  const constructorOptions = { max };
-  const cacheInstance = new LRUCaches(constructorOptions);
-  await cacheInstance.init();
-  return cacheInstance;
-}

package/src/libs/render/cache/page-caches/lru.ts

@@ -1,38 +0,0 @@
-import LRU from 'lru-cache';
-import { PageCache, PageCachesInterface } from '../type';
-
-export class LRUCaches implements PageCachesInterface {
-  caches: LRU<string, PageCache>;
-
-  private readonly max: number;
-
-  constructor(options: { max: number }) {
-    this.max = options.max;
-    this.caches = new LRU(this.max);
-  }
-
-  init() {
-    return Promise.resolve();
-  }
-
-  public keys(): string[] {
-    return this.caches.keys();
-  }
-
-  public get(key: string) {
-    return Promise.resolve(this.caches.get(key) || null);
-  }
-
-  public peek(key: string) {
-    return this.caches.peek(key) || null;
-  }
-
-  public set(key: string, cache: PageCache) {
-    this.caches.set(key, cache);
-    return Promise.resolve();
-  }
-
-  public del(key: string) {
-    this.caches.del(key);
-  }
-}