@modern-js/server 1.3.0 → 1.4.0

package/src/dev-tools/watcher/dependency-tree.ts

@@ -1,94 +0,0 @@
-import minimatch from 'minimatch';
-
-export const defaultIgnores = [
-  '**/bower_components/**',
-  '**/coverage/**',
-  '**/node_modules/**',
-  '**/.*/**',
-  '**/*.d.ts',
-  '**/*.log',
-];
-
-export interface DependencyTreeOptions {
-  root: string;
-  ignore?: string[];
-}
-
-export interface TreeNode {
-  module: NodeModule;
-  parent: Set<TreeNode>;
-  children: Set<TreeNode>;
-}
-
-/**
- * `require.cache` already is a dependency tree, however require cache's
- * `module.parent` is the module that first required. so we have to implement
- *  a new tree which revisit the cache tree to find all parent node
- */
-export class DependencyTree {
-  private readonly tree: Map<string, TreeNode>;
-
-  private readonly ignore: string[];
-
-  constructor() {
-    this.tree = new Map<string, TreeNode>();
-    this.ignore = [...defaultIgnores];
-  }
-
-  public getNode(path: string) {
-    return this.tree.get(path);
-  }
-
-  /**
-   * update dependency tree
-   *
-   * @param cache
-   */
-  public update(cache: any) {
-    this.tree.clear();
-
-    // insert all module that not ignored
-    Object.keys(cache).forEach(path => {
-      if (!this.shouldIgnore(path)) {
-        const module = cache[path];
-        this.tree.set(module.filename, {
-          module,
-          parent: new Set<TreeNode>(),
-          children: new Set<TreeNode>(),
-        });
-      }
-    });
-
-    // update treeNode parent and children
-    for (const treeNode of this.tree.values()) {
-      const { parent } = treeNode.module;
-      const { children } = treeNode.module;
-
-      if (parent && !this.shouldIgnore(parent.filename)) {
-        const parentTreeNode = this.tree.get(parent.filename)!;
-        if (parentTreeNode) {
-          treeNode.parent.add(parentTreeNode);
-        }
-      }
-
-      children.forEach(child => {
-        if (!this.shouldIgnore(child.filename)) {
-          const childTreeNode = this.tree.get(child.filename)!;
-          if (childTreeNode) {
-            treeNode.children.add(childTreeNode);
-            childTreeNode.parent.add(treeNode);
-          }
-        }
-      });
-    }
-  }
-
-  private shouldIgnore(path: string): boolean {
-    return (
-      !path ||
-      Boolean(
-        this.ignore.find(rule => minimatch.match([path], rule).length > 0),
-      )
-    );
-  }
-}

package/src/dev-tools/watcher/index.ts

@@ -1,77 +0,0 @@
-import chokidar, { FSWatcher } from 'chokidar';
-import { DependencyTree } from './dependency-tree';
-import { StatsCache } from './stats-cache';
-
-const getWatchedFiles = (watcher: chokidar.FSWatcher) => {
-  const watched = watcher.getWatched();
-  const files: string[] = [];
-  Object.keys(watched).forEach(dir => {
-    watched[dir].forEach((fileName: string) => {
-      files.push(`${dir}/${fileName}`);
-    });
-  });
-  return files;
-};
-
-export default class Watcher {
-  private dependencyTree: DependencyTree | null = null;
-
-  private watcher!: FSWatcher;
-
-  public listen(files: string[], callback: (changed: string) => void) {
-    const watched = files.filter(Boolean);
-
-    const cache = new StatsCache();
-    const watcher = chokidar.watch(watched, {
-      // 初始化的时候不触发 add、addDir 事件
-      ignoreInitial: true,
-    });
-
-    watcher.on('ready', () => {
-      cache.add(getWatchedFiles(watcher));
-    });
-
-    watcher.on('change', changed => {
-      if (cache.isDiff(changed)) {
-        cache.refresh(changed);
-        callback(changed);
-      }
-    });
-
-    watcher.on('add', changed => {
-      if (!cache.has(changed)) {
-        cache.add([changed]);
-        callback(changed);
-      }
-    });
-
-    watcher.on('unlink', changed => {
-      cache.del(changed);
-      callback(changed);
-    });
-
-    this.watcher = watcher;
-  }
-
-  public createDepTree() {
-    this.dependencyTree = new DependencyTree();
-  }
-
-  public updateDepTree() {
-    this.dependencyTree?.update(require.cache);
-  }
-
-  public cleanDepCache(filepath: string) {
-    const node = this.dependencyTree?.getNode(filepath);
-    if (node && require.cache[filepath]) {
-      delete require.cache[filepath];
-      for (const parentNode of node.parent.values()) {
-        this.cleanDepCache(parentNode.module.filename);
-      }
-    }
-  }
-
-  public close() {
-    return this.watcher.close();
-  }
-}

package/src/dev-tools/watcher/stats-cache.ts

@@ -1,53 +0,0 @@
-import fs from 'fs';
-
-export class StatsCache {
-  private readonly cachedStats: Record<string, number> = {};
-
-  public add(files: string[]) {
-    const { cachedStats } = this;
-    for (const filename of files) {
-      if (fs.existsSync(filename)) {
-        const stat = fs.statSync(filename);
-        if (stat.isFile() && !cachedStats[filename]) {
-          cachedStats[filename] = this.sign(stat);
-        }
-      }
-    }
-  }
-
-  public refresh(filename: string) {
-    const { cachedStats } = this;
-    if (fs.existsSync(filename)) {
-      const stat = fs.statSync(filename);
-      if (stat.isFile()) {
-        cachedStats[filename] = this.sign(stat);
-      }
-    }
-  }
-
-  public del(filename: string) {
-    if (this.cachedStats[filename]) {
-      delete this.cachedStats[filename];
-    }
-  }
-
-  public isDiff(filename: string) {
-    const { cachedStats } = this;
-    const stat = fs.statSync(filename);
-    const cachedStat = cachedStats[filename];
-
-    if (this.sign(stat) !== cachedStat) {
-      return true;
-    }
-    return false;
-  }
-
-  public has(filename: string) {
-    return Boolean(this.cachedStats[filename]);
-  }
-
-  // Todo size 其实有点问题，修改单个字符会导致触发不了 change
-  private sign(stat: fs.Stats) {
-    return stat.size;
-  }
-}

package/src/index.ts

@@ -1,16 +0,0 @@
-import { ModernServerOptions } from './type';
-import { Server } from './server';
-
-export type { SSRServerContext } from './libs/render/type';
-export { Server };
-export type { ModernServerOptions };
-
-export default (options: ModernServerOptions): Promise<Server> => {
-  if (options == null) {
-    throw new Error('can not start mserver without options');
-  }
-
-  const server = new Server(options);
-
-  return server.init();
-};

package/src/libs/context/context.ts

@@ -1,176 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { URL } from 'url';
-import qs from 'querystring';
-import type {
-  ModernServerContext as ModernServerContextInterface,
-  Metrics,
-  Logger,
-} from '@modern-js/types/server';
-import { toMessage } from '../../utils';
-
-export type ContextOptions = {
-  logger?: Logger;
-  metrics?: Metrics;
-};
-
-export class ModernServerContext implements ModernServerContextInterface {
-  /**
-   * http request
-   */
-  public req: IncomingMessage;
-
-  /**
-   * http response
-   */
-  public res: ServerResponse;
-
-  /**
-   * url params
-   */
-  public params: Record<string, string> = {};
-
-  public logger: Logger;
-
-  public metrics?: Metrics;
-
-  constructor(req: IncomingMessage, res: ServerResponse) {
-    this.req = req;
-    this.res = res;
-    this.logger = req.logger;
-    this.metrics = req.metrics;
-
-    this.bind();
-  }
-
-  private bind() {
-    const { req, res } = this as any;
-    req.get = (key: string) => this.getReqHeader(key);
-    res.set = (key: string, value: any) => this.res.setHeader(key, value);
-  }
-
-  public setParams(params: Record<string, string>) {
-    this.params = params;
-  }
-
-  public getReqHeader(key: string) {
-    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 */
-  public get headers() {
-    return this.req.headers;
-  }
-
-  public get method(): string {
-    return this.req.method!;
-  }
-
-  public get url() {
-    return this.req.url || '';
-  }
-
-  public set url(val) {
-    this.req.url = val;
-  }
-
-  public get host() {
-    let host = this.getReqHeader('X-Forwarded-Host');
-    if (!host) {
-      host = this.getReqHeader('Host');
-    }
-    return (host as string).split(/\s*,\s*/, 1)[0] || '';
-  }
-
-  public get protocol() {
-    if ((this.req.socket as any).encrypted) {
-      return 'https';
-    }
-
-    const proto = this.getReqHeader('X-Forwarded-Proto');
-    return proto ? (proto as string).split(/\s*,\s*/, 1)[0] : 'http';
-  }
-
-  public get origin() {
-    return `${this.protocol}://${this.host}`;
-  }
-
-  public get href() {
-    return this.origin + this.url;
-  }
-
-  public get parsedURL() {
-    const url = new URL(this.req.url!, this.origin);
-    return url;
-  }
-
-  public get path() {
-    return this.parsedURL.pathname;
-  }
-
-  public 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();
-  }
-
-  public get querystring() {
-    if (!this.req) {
-      return '';
-    }
-    return this.parsedURL.search.replace(/^\?/, '') || '';
-  }
-
-  public get query() {
-    const str = this.querystring;
-    return qs.parse(str);
-  }
-
-  /* response property */
-  public get status() {
-    return this.res.statusCode;
-  }
-
-  public set status(statusCode) {
-    this.res.statusCode = statusCode;
-  }
-
-  /**
-   * 判断链接是否已经关闭
-   */
-  public resHasHandled(): boolean {
-    return this.res.writableEnded;
-  }
-
-  public logInfo() {
-    return {
-      headers: this.headers,
-      href: this.href,
-      url: this.url,
-    };
-  }
-
-  public error(dig: string, err: Error | string = '') {
-    const message = toMessage(dig, err);
-    const reqInfo = this.logInfo();
-
-    this.logger.error(`${reqInfo.url} - ${message}`, reqInfo);
-  }
-}

package/src/libs/context/index.ts

@@ -1,7 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { ModernServerContext } from './context';
-
-export const createContext = (req: IncomingMessage, res: ServerResponse) =>
-  new ModernServerContext(req, res);
-
-export { ModernServerContext };

package/src/libs/hook-api/route.ts

@@ -1,38 +0,0 @@
-import { RouteMatchManager, RouteMatcher } from '../route';
-
-class RouteAPI {
-  private readonly router: RouteMatchManager;
-
-  private current: RouteMatcher;
-
-  constructor(matched: RouteMatcher, router: RouteMatchManager) {
-    this.current = matched;
-    this.router = router;
-  }
-
-  public cur() {
-    return this.current.generate();
-  }
-
-  public get(entryName: string) {
-    const { router } = this;
-    const matched = router.matchEntry(entryName);
-    return matched ? matched.generate() : null;
-  }
-
-  public use(entryName: string) {
-    const { router } = this;
-    const matched = router.matchEntry(entryName);
-    if (matched) {
-      this.current = matched;
-      return true;
-    } else {
-      return false;
-    }
-  }
-}
-
-export const createRouteAPI = (
-  matched: RouteMatcher,
-  router: RouteMatchManager,
-) => new RouteAPI(matched, router);

package/src/libs/hook-api/template.ts

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

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