@modern-js/server 1.2.2-beta.0 → 1.3.2

package/src/libs/metrics.ts

@@ -1,15 +0,0 @@
-import { Metrics } from '../type';
-
-const metrics: Metrics = {
-  gauges() {
-    // no impl
-  },
-  counter() {
-    // no impl
-  },
-  timer() {
-    // no impl
-  },
-};
-
-export { metrics };

package/src/libs/proxy.ts

@@ -1,85 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { createProxyMiddleware } from 'http-proxy-middleware';
-import { NextFunction } from '../type';
-import { ModernServerContext } from './context';
-
-type ProxyDetail = {
-  target: string;
-  pathRewrite?: Record<string, string>;
-  secure?: boolean;
-  logLevel?: 'debug' | 'info' | 'warn' | 'error' | 'silent';
-  bypass?: (
-    req: IncomingMessage,
-    res: ServerResponse,
-    proxyOptions: ProxyOptions,
-  ) => string | undefined | null | false;
-  context?: string | string[];
-  changeOrigin?: boolean;
-};
-
-export type ProxyOptions =
-  | Record<string, string>
-  | Record<string, ProxyDetail>
-  | ProxyDetail[]
-  | ProxyDetail;
-
-export const createProxyHandler = (proxyOptions: ProxyOptions) => {
-  if (!proxyOptions) {
-    return null;
-  }
-
-  // If it is not an array, it may be an object that uses the context attribute
-  // or an object in the form of { source: ProxyDetail }
-  const formatedProxy: ProxyDetail[] = [];
-  if (!Array.isArray(proxyOptions)) {
-    if ('target' in proxyOptions) {
-      formatedProxy.push(proxyOptions as ProxyDetail);
-    } else {
-      Array.prototype.push.apply(
-        formatedProxy,
-        Object.keys(proxyOptions).reduce(
-          (total: ProxyDetail[], source: string) => {
-            const option = proxyOptions[source];
-
-            total.push({
-              context: source,
-              changeOrigin: true,
-              logLevel: 'warn',
-              ...(typeof option === 'string' ? { target: option } : option),
-            });
-            return total;
-          },
-          [],
-        ),
-      );
-    }
-  } else {
-    formatedProxy.push(...proxyOptions);
-  }
-
-  const middlewares = formatedProxy.map(option => {
-    const middleware = createProxyMiddleware(option.context!, option);
-
-    // eslint-disable-next-line consistent-return
-    return async (ctx: ModernServerContext, next: NextFunction) => {
-      const { req, res } = ctx;
-      const bypassUrl =
-        typeof option.bypass === 'function'
-          ? option.bypass(req, res, option)
-          : null;
-
-      // only false, no true
-      if (typeof bypassUrl === 'boolean') {
-        ctx.status = 404;
-        return next();
-      } else if (typeof bypassUrl === 'string') {
-        ctx.url = bypassUrl;
-        return next();
-      }
-
-      (middleware as any)(req, res, next);
-    };
-  });
-
-  return middlewares;
-};

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

@@ -1,94 +0,0 @@
-import url from 'url';
-import { createCache, destroyCache } from '../spr';
-import {
-  cacheAddition,
-  connectFactor,
-  fname,
-  maybeSync,
-  namespaceHash,
-  valueFactory,
-  withCoalescedInvoke,
-} from '../util';
-
-describe('test spr util functions', () => {
-  it('should return value correctly', () => {
-    expect(connectFactor('bar', 'foo')).toBe('bar-foo');
-    expect(fname(1)).toBe('f1');
-    expect(namespaceHash('modern', '!@#$%^&')).toBe('modern/!@#$%^&');
-  });
-
-  it('should create or destroy instance correctly', () => {
-    const ins1 = createCache();
-    const ins2 = createCache();
-    expect(ins1 === ins2).toBe(true);
-    destroyCache();
-    const ins3 = createCache();
-    expect(ins1 === ins3).toBe(false);
-    expect(ins2 === ins3).toBe(false);
-  });
-
-  it('should return function correctly', () => {
-    const urlParams: any = (() => new url.URLSearchParams())();
-    urlParams.set('name', 'modern');
-    const getParam = valueFactory(urlParams);
-    expect(getParam('name')).toBe('modern');
-    const headers: any = { age: '12345' };
-    const getHeader = valueFactory(headers);
-    expect(getHeader('age')).toBe('12345');
-  });
-
-  it('should add target html content', () => {
-    const contentNoHead = '<div>123</div>';
-    const html = cacheAddition(contentNoHead, Math.random().toString());
-    expect(html).toBe(contentNoHead);
-
-    const contentWithHead = '<head></head><div>123</div>';
-    const hash = Math.random().toString();
-    const htmlWithHead = cacheAddition(contentWithHead, hash);
-    expect(htmlWithHead).toBe(
-      `<head><meta name="x-moden-spr" content="${hash}"></head><div>123</div>`,
-    );
-  });
-
-  it('should only invoke func one time', async () => {
-    let index = 0;
-    const fn = withCoalescedInvoke(
-      async () =>
-        new Promise(resolve => {
-          setTimeout(() => {
-            index += 1;
-            resolve(index);
-          }, 500);
-        }),
-    );
-    const key = 'test';
-    const [res1, res2] = await Promise.all([fn(key, []), fn(key, [])]);
-    expect(res1.isOrigin && res2.isOrigin).toBe(false);
-    expect(res1.isOrigin || res2.isOrigin).toBe(true);
-    expect(res1.value).toBe(1);
-    expect(res2.value).toBe(1);
-  });
-
-  it('should invoke sync or async', async () => {
-    const foo = '';
-    const async = await maybeSync(
-      () =>
-        new Promise(resolve => {
-          setTimeout(() => {
-            resolve(foo);
-          }, 100);
-        }),
-    )(false);
-    expect(async).toBeUndefined();
-
-    const sync = await maybeSync(
-      () =>
-        new Promise(resolve => {
-          setTimeout(() => {
-            resolve(foo);
-          }, 100);
-        }),
-    )(true);
-    expect(sync).toBe(foo);
-  });
-});

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;
-}