@modern-js/prod-server 1.0.1

package/CHANGELOG.md

@@ -0,0 +1,16 @@
+# @modern-js/prod-server
+
+## 1.0.1
+### Patch Changes
+
+- 02fb4146: support product server
+- Updated dependencies [969f172f]
+- Updated dependencies [4c792f68]
+- Updated dependencies [4b5d4bf4]
+- Updated dependencies [62f5b8c8]
+- Updated dependencies [55e18278]
+- Updated dependencies [4499a674]
+- Updated dependencies [403f5169]
+- Updated dependencies [a7f42f48]
+  - @modern-js/core@1.4.4
+  - @modern-js/utils@1.3.3

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021 Modern.js
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,30 @@
+
+<p align="center">
+  <a href="https://modernjs.dev" target="blank"><img src="https://lf3-static.bytednsdoc.com/obj/eden-cn/ylaelkeh7nuhfnuhf/modernjs-cover.png" width="300" alt="Modern.js Logo" /></a>
+</p>
+<p align="center">
+现代 Web 工程体系
+  <br/>
+  <a href="https://modernjs.dev" target="blank">
+    modernjs.dev
+  </a>
+</p>
+<p align="center">
+  The meta-framework suite designed from scratch for frontend-focused modern web development
+</p>
+
+# Introduction
+
+> The doc site ([modernjs.dev](https://modernjs.dev)) and articles are only available in Chinese for now, we are planning to add English versions soon.
+
+- [Modern.js: Hello, World!](https://zhuanlan.zhihu.com/p/426707646)
+
+## Getting Started
+
+- [Quick Start](https://modernjs.dev/docs/start)
+- [Guides](https://modernjs.dev/docs/guides)
+- [API References](https://modernjs.dev/docs/apis)
+
+## Contributing
+
+- [Contributing Guide](https://github.com/modern-js-dev/modern.js/blob/main/CONTRIBUTING.md)

package/dist/js/modern/constants.js

@@ -0,0 +1,26 @@
+export const AGGRED_DIR = {
+  mock: 'config/mock',
+  server: 'server',
+  api: 'api',
+  shared: 'shared',
+  lambda: 'lambda'
+};
+export let ApiServerMode;
+
+(function (ApiServerMode) {
+  ApiServerMode["func"] = "function";
+  ApiServerMode["frame"] = "framework";
+})(ApiServerMode || (ApiServerMode = {}));
+
+export const ERROR_DIGEST = {
+  INIT: 'Server init error',
+  ENOTF: 'Page could not be found',
+  WARMUP: 'SSR warmup failed',
+  EINTER: 'Internal server error',
+  ERENDER: 'SSR render failed',
+  EMICROINJ: 'Get micro-frontend info failed'
+};
+export const ERROR_PAGE_TEXT = {
+  404: 'This page could not be found.',
+  500: 'Internal Server Error.'
+};

package/dist/js/modern/index.js

@@ -0,0 +1,14 @@
+import { Server } from "./server";
+export { Server };
+export { ModernServer } from "./server/modern-server";
+export { createProxyHandler } from "./libs/proxy";
+export * from "./type";
+export * from "./constants";
+export default (options => {
+  if (options == null) {
+    throw new Error('can not start mserver without options');
+  }
+
+  const server = new Server(options);
+  return server.init();
+});

package/dist/js/modern/libs/context/context.js

@@ -0,0 +1,180 @@
+import { URL } from 'url';
+import qs from 'querystring';
+import { toMessage } from "../../utils";
+export class ModernServerContext {
+  /**
+   * http request
+   */
+
+  /**
+   * http response
+   */
+
+  /**
+   * url params
+   */
+  constructor(req, res) {
+    this.req = void 0;
+    this.res = void 0;
+    this.params = {};
+    this.logger = void 0;
+    this.metrics = void 0;
+    this.serverData = void 0;
+    this.req = req;
+    this.res = res;
+    this.logger = req.logger;
+    this.metrics = req.metrics;
+    this.serverData = {};
+    this.bind();
+  }
+
+  bind() {
+    const {
+      req,
+      res
+    } = this;
+
+    req.get = key => this.getReqHeader(key);
+
+    res.set = (key, value) => this.res.setHeader(key, value);
+  }
+
+  setParams(params) {
+    this.params = params;
+  }
+
+  setServerData(key, value) {
+    this.serverData[key] = value;
+  }
+
+  getReqHeader(key) {
+    const {
+      req
+    } = this;
+    const field = key.toLowerCase();
+
+    switch (field) {
+      case 'referer':
+      case 'referrer':
+        return req.headers.referrer || req.headers.referer || '';
+
+      default:
+        return req.headers[field] || '';
+    }
+  }
+  /* request property */
+
+
+  get headers() {
+    return this.req.headers;
+  }
+
+  get method() {
+    return this.req.method;
+  }
+
+  get url() {
+    return this.req.url || '';
+  }
+
+  set url(val) {
+    this.req.url = val;
+  }
+
+  get host() {
+    let host = this.getReqHeader('X-Forwarded-Host');
+
+    if (!host) {
+      host = this.getReqHeader('Host');
+    }
+
+    return host.split(/\s*,\s*/, 1)[0] || '';
+  }
+
+  get protocol() {
+    if (this.req.socket.encrypted) {
+      return 'https';
+    }
+
+    const proto = this.getReqHeader('X-Forwarded-Proto');
+    return proto ? proto.split(/\s*,\s*/, 1)[0] : 'http';
+  }
+
+  get origin() {
+    return `${this.protocol}://${this.host}`;
+  }
+
+  get href() {
+    return this.origin + this.url;
+  }
+
+  get parsedURL() {
+    const url = new URL(this.req.url, this.origin);
+    return url;
+  }
+
+  get path() {
+    return this.parsedURL.pathname;
+  }
+
+  set path(p) {
+    const url = new URL(this.req.url, this.origin); // this should never happend
+
+    if (!url || !p) {
+      return;
+    }
+
+    if (url.pathname === p) {
+      return;
+    }
+
+    url.pathname = p;
+    this.url = url.toString();
+  }
+
+  get querystring() {
+    if (!this.req) {
+      return '';
+    }
+
+    return this.parsedURL.search.replace(/^\?/, '') || '';
+  }
+
+  get query() {
+    const str = this.querystring;
+    return qs.parse(str);
+  }
+  /* response property */
+
+
+  get status() {
+    return this.res.statusCode;
+  }
+
+  set status(statusCode) {
+    this.res.statusCode = statusCode;
+  }
+  /**
+   * 判断链接是否已经关闭
+   */
+
+
+  resHasHandled() {
+    return this.res.writableEnded;
+  }
+
+  logInfo() {
+    return {
+      headers: this.headers,
+      href: this.href,
+      url: this.url
+    };
+  }
+
+  error(dig, err = '') {
+    const message = toMessage(dig, err);
+    const reqInfo = this.logInfo();
+    this.logger.error(`${reqInfo.url} - ${message}`, reqInfo);
+  }
+
+}

package/dist/js/modern/libs/context/index.js

@@ -0,0 +1,3 @@
+import { ModernServerContext } from "./context";
+export const createContext = (req, res) => new ModernServerContext(req, res);
+export { ModernServerContext };

package/dist/js/modern/libs/hook-api/route.js

@@ -0,0 +1,39 @@
+class RouteAPI {
+  constructor(matched, router, url) {
+    this.router = void 0;
+    this.current = void 0;
+    this.url = void 0;
+    this.current = matched;
+    this.router = router;
+    this.url = url;
+  }
+
+  cur() {
+    return this.current.generate(this.url);
+  }
+
+  get(entryName) {
+    const {
+      router
+    } = this;
+    const matched = router.matchEntry(entryName);
+    return matched ? matched.generate(this.url) : null;
+  }
+
+  use(entryName) {
+    const {
+      router
+    } = this;
+    const matched = router.matchEntry(entryName);
+
+    if (matched) {
+      this.current = matched;
+      return true;
+    } else {
+      return false;
+    }
+  }
+
+}
+
+export const createRouteAPI = (matched, router, url) => new RouteAPI(matched, router, url);

package/dist/js/modern/libs/hook-api/template.js

@@ -0,0 +1,61 @@
+const RegList = {
+  before: {
+    head: '<head>',
+    body: '<body>'
+  },
+  after: {
+    head: '</head>',
+    body: '</body>'
+  }
+};
+
+class TemplateAPI {
+  constructor(content) {
+    this.content = void 0;
+    this.content = content;
+  }
+
+  get() {
+    return this.content;
+  }
+
+  set(content) {
+    this.content = content;
+  }
+
+  prependHead(fragment) {
+    const {
+      head
+    } = RegList.before;
+    return this.replace(head, `${head}${fragment}`);
+  }
+
+  appendHead(fragment) {
+    const {
+      head
+    } = RegList.after;
+    return this.replace(head, `${fragment}${head}`);
+  }
+
+  prependBody(fragment) {
+    const {
+      body
+    } = RegList.before;
+    return this.replace(body, `${body}${fragment}`);
+  }
+
+  appendBody(fragment) {
+    const {
+      body
+    } = RegList.after;
+    return this.replace(body, `${fragment}${body}`);
+  }
+
+  replace(reg, text) {
+    this.content = this.content.replace(reg, text);
+    return this;
+  }
+
+}
+
+export const createTemplateAPI = content => new TemplateAPI(content);

package/dist/js/modern/libs/metrics.js

@@ -0,0 +1,12 @@
+const metrics = {
+  gauges() {// no impl
+  },
+
+  counter() {// no impl
+  },
+
+  timer() {// no impl
+  }
+
+};
+export { metrics };

package/dist/js/modern/libs/proxy.js

@@ -0,0 +1,33 @@
+import { createProxyMiddleware } from 'http-proxy-middleware';
+import { formatProxyOptions } from '@modern-js/utils';
+export const createProxyHandler = 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 = formatProxyOptions(proxyOptions);
+  const middlewares = formatedProxy.map(option => {
+    const middleware = createProxyMiddleware(option.context, option); // eslint-disable-next-line consistent-return
+
+    return async (ctx, next) => {
+      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(req, res, next);
+    };
+  });
+  return middlewares;
+};

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

@@ -0,0 +1,70 @@
+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 = (() => new url.URLSearchParams())();
+
+    urlParams.set('name', 'modern');
+    const getParam = valueFactory(urlParams);
+    expect(getParam('name')).toBe('modern');
+    const headers = {
+      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);
+  });
+});