@modern-js/server 1.3.1-beta.0 → 1.4.1

package/src/dev-tools/socket-server.ts

@@ -1,192 +0,0 @@
-import { Server } from 'http';
-import { Socket } from 'net';
-import ws from 'ws';
-import type { Stats } from 'webpack';
-import { logger } from '@modern-js/utils';
-import { DevServerOptions } from '../type';
-import { noop } from '../utils';
-
-interface ExtWebSocket extends ws {
-  isAlive: boolean;
-}
-
-export default class SocketServer {
-  private wsServer!: ws.Server;
-
-  private readonly sockets: ws[] = [];
-
-  private readonly options: DevServerOptions;
-
-  private app?: Server;
-
-  private stats?: Stats;
-
-  constructor(options: DevServerOptions) {
-    this.options = options;
-  }
-
-  // create socket, install socket handler, bind socket event
-  public prepare(app: Server) {
-    this.app = app;
-
-    this.wsServer = new ws.Server({
-      noServer: true,
-      path: this.options.client.path,
-    });
-
-    // listen upgrade event to handle socket
-    this.app.on('upgrade', (req, sock, head) => {
-      if (!this.wsServer.shouldHandle(req)) {
-        return;
-      }
-
-      this.wsServer.handleUpgrade(req, sock as Socket, head, connection => {
-        this.wsServer.emit('connection', connection, req);
-      });
-    });
-
-    this.wsServer.on('error', (err: Error) => {
-      // only dev server, use default logger
-      logger.error(err);
-    });
-
-    setInterval(() => {
-      this.wsServer.clients.forEach(socket => {
-        const extWs = socket as ExtWebSocket;
-        if (!extWs.isAlive) {
-          extWs.terminate();
-        } else {
-          extWs.isAlive = false;
-          extWs.ping(noop);
-        }
-      });
-    }, 30000);
-
-    this.wsServer.on('connection', socket => {
-      const connection = socket as ExtWebSocket;
-
-      connection.isAlive = true;
-      connection.on('pong', () => {
-        connection.isAlive = true;
-      });
-
-      if (!connection) {
-        return;
-      }
-
-      this.sockets.push(connection);
-
-      connection.on('close', () => {
-        const idx = this.sockets.indexOf(connection);
-
-        if (idx >= 0) {
-          this.sockets.splice(idx, 1);
-        }
-      });
-
-      if (this.options.client.logging) {
-        this.sockWrite('logging', this.options.client.logging);
-      }
-
-      if (this.options.hot || this.options.hot === 'only') {
-        this.sockWrite('hot');
-      }
-
-      if (this.options.liveReload) {
-        this.sockWrite('liveReload');
-      }
-
-      if (this.options.client.progress) {
-        this.sockWrite('progress', this.options.client.progress);
-      }
-
-      if (this.options.client.overlay) {
-        this.sockWrite('overlay', this.options.client.overlay);
-      }
-
-      // send first stats to active client sock if stats exist
-      if (this.stats) {
-        this.sendStats(true);
-      }
-    });
-  }
-
-  public updateStats(stats: Stats) {
-    this.stats = stats;
-    this.sendStats();
-  }
-
-  // write message to each socket
-  public sockWrite(
-    type: string,
-    data?: Record<string, any> | string | boolean,
-  ) {
-    this.sockets.forEach(socket => {
-      this.send(socket, JSON.stringify({ type, data }));
-    });
-  }
-
-  public close(connection: ws) {
-    connection.close();
-  }
-
-  // get standard stats
-  private getStats() {
-    const curStats = this.stats;
-
-    if (!curStats) {
-      return null;
-    }
-
-    const defaultStats: Record<string, boolean> = {
-      all: false,
-      hash: true,
-      assets: true,
-      warnings: true,
-      errors: true,
-      errorDetails: false,
-    };
-
-    return curStats.toJson(defaultStats);
-  }
-
-  // determine what message should send by stats
-  private sendStats(force = false) {
-    const stats = this.getStats();
-
-    // this should never happend
-    if (!stats) {
-      return null;
-    }
-
-    const shouldEmit =
-      !force &&
-      stats &&
-      (!stats.errors || stats.errors.length === 0) &&
-      stats.assets &&
-      stats.assets.every((asset: any) => !asset.emitted);
-
-    if (shouldEmit) {
-      return this.sockWrite('still-ok');
-    }
-
-    this.sockWrite('hash', stats.hash);
-
-    if (stats.errors && stats.errors.length > 0) {
-      return this.sockWrite('errors', stats.errors);
-    } else if (stats.warnings && stats.warnings.length > 0) {
-      return this.sockWrite('warnings', stats.warnings);
-    } else {
-      return this.sockWrite('ok');
-    }
-  }
-
-  // send message to connecting socket
-  private send(connection: ws, message: string) {
-    if (connection.readyState !== 1) {
-      return;
-    }
-
-    connection.send(message);
-  }
-}

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,81 +0,0 @@
-import chokidar, { FSWatcher, WatchOptions } 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[],
-    options: WatchOptions,
-    callback: (changed: string) => void,
-  ) {
-    const watched = files.filter(Boolean);
-    const filenames = watched.map(filename => filename.replace(/\\/g, '/'));
-    // eslint-disable-next-line no-console
-    console.log('watched files:', filenames);
-
-    const cache = new StatsCache();
-    const watcher = chokidar.watch(filenames, options);
-
-    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);