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

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

@@ -1,300 +0,0 @@
-import http, {
-  Server,
-  createServer,
-  IncomingMessage,
-  ServerResponse,
-} from 'http';
-import path from 'path';
-import { createServer as createHttpsServer } from 'https';
-import {
-  API_DIR,
-  HMR_SOCK_PATH,
-  SERVER_DIR,
-  SHARED_DIR,
-} from '@modern-js/utils';
-import type { MultiCompiler, Compiler } from 'webpack';
-import webpackDevMiddleware from 'webpack-dev-middleware';
-import { ModernServer } from '../modern-server';
-import { createMockHandler } from '../../dev-tools/mock';
-import { createProxyHandler, ProxyOptions } from '../../libs/proxy';
-import {
-  DevServerOptions,
-  ModernServerOptions,
-  NextFunction,
-  ServerHookRunner,
-  ReadyOptions,
-} from '../../type';
-import SocketServer from '../../dev-tools/socket-server';
-import DevServerPlugin from '../../dev-tools/dev-server-plugin';
-import { ModernServerContext } from '../../libs/context';
-import { createLaunchEditorHandler } from '../../dev-tools/launch-editor';
-import { enableRegister } from '../../dev-tools/babel/register';
-import * as reader from '../../libs/render/reader';
-import Watcher from '../../dev-tools/watcher';
-import { AGGRED_DIR } from '../../constants';
-
-const DEFAULT_DEV_OPTIONS: DevServerOptions = {
-  client: {
-    port: '8080',
-    overlay: false,
-    logging: 'none',
-    path: HMR_SOCK_PATH,
-    host: 'localhost',
-  },
-  https: false,
-  dev: { writeToDisk: true },
-  watch: true,
-  hot: true,
-  liveReload: true,
-};
-
-export class ModernDevServer extends ModernServer {
-  private devProxyHandler: ReturnType<typeof createProxyHandler> = null;
-
-  private mockHandler: ReturnType<typeof createMockHandler> = null;
-
-  private readonly dev: DevServerOptions;
-
-  private readonly compiler?: MultiCompiler | Compiler;
-
-  private socketServer!: SocketServer;
-
-  private watcher!: Watcher;
-
-  private devMiddleware!: webpackDevMiddleware.API<
-    http.IncomingMessage,
-    http.ServerResponse
-  >;
-
-  constructor(options: ModernServerOptions) {
-    super(options);
-
-    // set webpack compiler
-    this.compiler = options.compiler!;
-
-    // set dev server options, like webpack-dev-server
-    this.dev =
-      typeof options.dev === 'boolean'
-        ? DEFAULT_DEV_OPTIONS
-        : { ...DEFAULT_DEV_OPTIONS, ...options.dev };
-
-    enableRegister(this.pwd, this.conf);
-  }
-
-  // Complete the preparation of services
-  public async init(runner: ServerHookRunner) {
-    const { conf, pwd, compiler } = this;
-    // mock handler
-    this.mockHandler = createMockHandler({ pwd });
-    this.addHandler((ctx: ModernServerContext, next: NextFunction) => {
-      ctx.res.setHeader('Access-Control-Allow-Origin', '*');
-      ctx.res.setHeader('Access-Control-Allow-Credentials', 'false');
-
-      if (this.mockHandler) {
-        this.mockHandler(ctx, next);
-      } else {
-        next();
-      }
-    });
-
-    // dev proxy handler, each proxy has own handler
-    this.devProxyHandler = createProxyHandler(
-      conf.tools?.devServer?.proxy as ProxyOptions,
-    );
-    if (this.devProxyHandler) {
-      this.devProxyHandler.forEach(handler => {
-        this.addHandler(handler);
-      });
-    }
-
-    // do webpack build / plugin apply / socket server when pass compiler instance
-    if (compiler) {
-      // init socket server
-      this.socketServer = new SocketServer(this.dev);
-
-      // open file in edtor.
-      this.addHandler(createLaunchEditorHandler());
-
-      // setup compiler in server, also add dev-middleware to handler static file in memory
-      const devMiddlewareHandler = this.setupCompiler(compiler);
-      this.addHandler(devMiddlewareHandler);
-    }
-
-    await super.init(runner);
-
-    // watch mock/ server/ api/ dir file change
-    if (this.dev.watch) {
-      this.startWatcher();
-    }
-  }
-
-  public ready(options: ReadyOptions = {}) {
-    // reset the routing management instance every times the service starts
-    this.router.reset(
-      this.filterRoutes(options.routes || this.presetRoutes || []),
-    );
-    this.cleanSSRCache();
-
-    // reset static file
-    reader.updateFile();
-
-    this.runner.reset();
-  }
-
-  public onListening(app: Server) {
-    this.socketServer?.prepare(app);
-  }
-
-  public async close() {
-    super.close();
-    await this.watcher.close();
-    await new Promise<void>(resolve => {
-      if (this.devMiddleware) {
-        this.devMiddleware.close(() => {
-          resolve();
-        });
-      } else {
-        resolve();
-      }
-    });
-  }
-
-  public async createHTTPServer(
-    handler: (
-      req: IncomingMessage,
-      res: ServerResponse,
-      next?: () => void,
-    ) => void,
-  ) {
-    const { dev } = this;
-    const devHttpsOption = typeof dev === 'object' && dev.https;
-    if (devHttpsOption) {
-      const { genHttpsOptions } = require('../../dev-tools/https');
-      const httpsOptions = await genHttpsOptions(devHttpsOption);
-      return createHttpsServer(httpsOptions, handler);
-    } else {
-      return createServer(handler);
-    }
-  }
-
-  // set up plugin to each compiler
-  // register hooks for each compilation, update socket stats if recompiled
-  // start dev middleware
-  private setupCompiler(compiler: MultiCompiler | Compiler) {
-    this.setupDevServerPlugin(compiler);
-    this.setupHooks();
-    return this.setupDevMiddleware(compiler);
-  }
-
-  private setupDevServerPlugin(compiler: MultiCompiler | Compiler) {
-    const { dev: devConf } = this;
-    if ((compiler as MultiCompiler).compilers) {
-      (compiler as MultiCompiler).compilers.forEach(target => {
-        if (target.name === 'client') {
-          new DevServerPlugin(devConf).apply(target);
-        }
-      });
-    } else {
-      new DevServerPlugin(devConf).apply(compiler as Compiler);
-    }
-  }
-
-  private setupHooks() {
-    const invalidPlugin = () => {
-      this.socketServer.sockWrite('invalid');
-    };
-
-    const addHooks = (compiler: Compiler) => {
-      const { compile, invalid, done } = compiler.hooks;
-
-      compile.tap('modern-dev-server', invalidPlugin);
-      invalid.tap('modern-dev-server', invalidPlugin);
-      done.tap('modern-dev-server', (stats: any) => {
-        this.socketServer.updateStats(stats);
-
-        // Reset only when client compile done
-        if (stats.toJson({ all: false }).name === 'client') {
-          this.ready({ routes: this.readRouteSpec() });
-        }
-      });
-    };
-
-    if ((this.compiler as MultiCompiler).compilers) {
-      (this.compiler as MultiCompiler).compilers.forEach(addHooks);
-    } else {
-      addHooks(this.compiler as Compiler);
-    }
-  }
-
-  private setupDevMiddleware(compiler: MultiCompiler | Compiler) {
-    this.devMiddleware = webpackDevMiddleware(compiler, {
-      publicPath: '/',
-      writeToDisk: this.dev.dev.writeToDisk,
-      stats: false,
-    });
-
-    return (ctx: ModernServerContext, next: NextFunction) => {
-      const { req, res } = ctx;
-      this.devMiddleware(req, res, next);
-    };
-  }
-
-  private cleanSSRCache() {
-    const { distDir } = this;
-    const bundles = this.router.getBundles();
-
-    bundles.forEach(bundle => {
-      const filepath = path.join(distDir, bundle as string);
-      if (require.cache[filepath]) {
-        delete require.cache[filepath];
-      }
-    });
-  }
-
-  private startWatcher() {
-    const { pwd } = this;
-    const { mock } = AGGRED_DIR;
-    const defaultWatched = [
-      `${mock}/**/*`,
-      `${SERVER_DIR}/**/*`,
-      `${API_DIR}/**`,
-      `${SHARED_DIR}/**/*`,
-    ];
-
-    const defaultWatchedPaths = defaultWatched.map(p =>
-      path.normalize(path.join(pwd, p)),
-    );
-    const mockPath = path.normalize(path.join(pwd, mock));
-
-    const watcher = new Watcher();
-    watcher.createDepTree();
-
-    // 监听文件变动，如果有变动则给 client，也就是 start 启动的插件发消息
-    watcher.listen(
-      defaultWatchedPaths,
-      {
-        // 初始化的时候不触发 add、addDir 事件
-        ignoreInitial: true,
-        ignored: /api\/typings\/.*/,
-      },
-      (filepath: string) => {
-        watcher.updateDepTree();
-        watcher.cleanDepCache(filepath);
-
-        this.runner.reset();
-
-        if (filepath.startsWith(mockPath)) {
-          this.mockHandler = createMockHandler({ pwd });
-        } else {
-          try {
-            this.prepareFrameHandler();
-          } catch (e) {
-            this.logger.error(e as Error);
-          }
-        }
-      },
-    );
-
-    this.watcher = watcher;
-  }
-}

package/src/server/dev-server/index.ts

@@ -1,2 +0,0 @@
-export { ModernAPIDevServer, ModernSSRDevServer } from './dev-server-split';
-export { ModernDevServer } from './dev-server';

package/src/server/index.ts

@@ -1,163 +0,0 @@
-import { IncomingMessage, ServerResponse, Server as httpServer } from 'http';
-import path from 'path';
-import { serverManager } from '@modern-js/server-plugin';
-import { logger as defaultLogger } from '@modern-js/utils';
-import {
-  AppContext,
-  initAppContext,
-  initAppDir,
-  loadUserConfig,
-  ConfigContext,
-  UserConfig,
-} from '@modern-js/core';
-import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '../type';
-import { metrics as defaultMetrics } from '../libs/metrics';
-import { ModernServer } from './modern-server';
-import type { ModernDevServer } from './dev-server';
-import {
-  ModernAPIServer,
-  ModernSSRServer,
-  ModernWebServer,
-} from './modern-server-split';
-
-export class Server {
-  public options: ModernServerOptions;
-
-  private server!: ModernServer | ModernDevServer;
-
-  private app!: httpServer;
-
-  private runner!: ServerHookRunner;
-
-  constructor(options: ModernServerOptions) {
-    this.options = options;
-  }
-
-  public getRequestHandler() {
-    return (req: IncomingMessage, res: ServerResponse, next?: () => void) => {
-      const requestHandler = this.server.getRequestHandler();
-      return requestHandler(req, res, next);
-    };
-  }
-
-  public ready(readyOptions: ReadyOptions = {}) {
-    this.server.ready(readyOptions);
-  }
-
-  public async init() {
-    const { options } = this;
-
-    options.logger = options.logger || defaultLogger;
-    options.metrics = options.metrics || defaultMetrics;
-
-    // initialize server
-    if (options.dev) {
-      this.server = this.createDevServer();
-    } else {
-      this.server = this.createProdServer();
-    }
-    // check if https is configured when start dev server
-    this.app = await this.server.createHTTPServer(this.getRequestHandler());
-
-    this.runner = await this.createHookRunner();
-
-    // runner can only be used after server init
-    await this.server.init(this.runner);
-
-    return this;
-  }
-
-  public listen(port = 8080, listener: any) {
-    this.app.listen(process.env.PORT || port, () => {
-      if (listener) {
-        listener();
-      }
-
-      this.listener(this.app);
-    });
-  }
-
-  public listener(app: httpServer) {
-    this.server.onListening(app);
-  }
-
-  public async close() {
-    await this.server.close();
-    await new Promise<void>(resolve =>
-      this.app.close(() => {
-        resolve();
-      }),
-    );
-  }
-
-  private createProdServer() {
-    const { options } = this;
-
-    if (options.apiOnly) {
-      return new ModernAPIServer(options);
-    } else if (options.ssrOnly) {
-      return new ModernSSRServer(options);
-    } else if (options.webOnly) {
-      return new ModernWebServer(options);
-    } else {
-      return new ModernServer(options);
-    }
-  }
-
-  private createDevServer() {
-    const { options } = this;
-    const {
-      ModernAPIDevServer,
-      ModernSSRDevServer,
-      ModernDevServer,
-    } = require('./dev-server');
-
-    if (options.apiOnly) {
-      return new ModernAPIDevServer(options);
-    } else if (options.ssrOnly) {
-      return new ModernSSRDevServer(options);
-    } else {
-      return new ModernDevServer(options);
-    }
-  }
-
-  private async createHookRunner() {
-    const { options } = this;
-
-    options.plugins?.forEach(p => {
-      serverManager.usePlugin(p);
-    });
-
-    const appContext = await this.initAppContext();
-    serverManager.run(() => {
-      ConfigContext.set(this.options.config as UserConfig);
-      AppContext.set({
-        ...appContext,
-        distDirectory: path.join(
-          options.pwd,
-          options.config.output?.path || 'dist',
-        ),
-      });
-    });
-
-    return serverManager.init({});
-  }
-
-  private async initAppContext() {
-    const appDirectory = await initAppDir();
-
-    const loaded = await loadUserConfig(appDirectory);
-
-    const plugins = this.options.plugins?.map(p => ({
-      server: p,
-      cli: undefined,
-    }));
-
-    const appContext = initAppContext(
-      appDirectory,
-      plugins || [],
-      loaded.filePath,
-    );
-    return appContext;
-  }
-}

package/src/server/modern-server-split.ts

@@ -1,97 +0,0 @@
-import { APIServerStartInput } from '@modern-js/server-plugin';
-import { mergeExtension } from '../utils';
-import { ModernRoute, ModernRouteInterface, RouteMatcher } from '../libs/route';
-import { ApiServerMode } from '../constants';
-import { ModernServerContext } from '../libs/context';
-import { ModernServer } from './modern-server';
-
-export class ModernSSRServer extends ModernServer {
-  // Todo should not invoke any route hook in modernSSRServer
-
-  protected async warmupSSRBundle() {
-    // empty
-  }
-
-  protected verifyMatch(context: ModernServerContext, matched: RouteMatcher) {
-    if (matched.generate().isApi) {
-      this.render404(context);
-    }
-  }
-
-  protected prepareAPIHandler(
-    _m: ApiServerMode,
-    _: APIServerStartInput['config'],
-  ) {
-    return null as any;
-  }
-
-  protected async prepareWebHandler(
-    extension: ReturnType<typeof mergeExtension>,
-  ) {
-    return super.prepareWebHandler(extension);
-  }
-
-  // protected filterRoutes(routes: ModernRouteInterface[]) {
-  //   return routes.filter(route => route.entryName);
-  // }
-
-  protected async preServerInit() {
-    // empty
-  }
-}
-
-export class ModernAPIServer extends ModernServer {
-  protected async emitRouteHook(_: string, _input: any) {
-    // empty
-  }
-
-  protected async warmupSSRBundle() {
-    // empty
-  }
-
-  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>) {
-    return null as any;
-  }
-
-  protected async prepareAPIHandler(
-    mode: ApiServerMode,
-    extension: APIServerStartInput['config'],
-  ) {
-    return super.prepareAPIHandler(mode, extension);
-  }
-
-  protected filterRoutes(routes: ModernRouteInterface[]) {
-    return routes.filter(route => route.isApi);
-  }
-
-  protected async preServerInit() {
-    // empty
-  }
-}
-
-export class ModernWebServer extends ModernServer {
-  protected async warmupSSRBundle() {
-    // empty
-  }
-
-  protected async handleAPI(context: ModernServerContext) {
-    const { proxyTarget } = this;
-    if (!proxyTarget?.api) {
-      this.proxy();
-    } else {
-      this.render404(context);
-    }
-  }
-
-  protected async handleWeb(context: ModernServerContext, route: ModernRoute) {
-    const { proxyTarget } = this;
-
-    if (route.isSSR && proxyTarget?.ssr) {
-      return this.proxy();
-    } else {
-      // if no proxyTarget but access web server, degradation to csr
-      route.isSSR = false;
-      return super.handleWeb(context, route);
-    }
-  }
-}