@modern-js/server 0.0.0-plugins-202111301002 → 0.0.0-runtime-2021112193858

package/src/server/index.ts

@@ -1,16 +1,24 @@
-import {
-  IncomingMessage,
-  ServerResponse,
-  createServer,
-  Server as httpServer,
-} from 'http';
-import { createServer as createHttpsServer } from 'https';
+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 { ModernServerOptions, ServerHookRunner, ReadyOptions } from '../type';
+import {
+  AppContext,
+  initAppContext,
+  initAppDir,
+  loadUserConfig,
+  ConfigContext,
+  UserConfig,
+} from '@modern-js/core';
 import { ModernServer } from './modern-server';
 import type { ModernDevServer } from './dev-server';
-import { measure as defaultMeasure } from '@/libs/measure';
+import {
+  ModernAPIServer,
+  ModernSSRServer,
+  ModernWebServer,
+} from './modern-server-split';
+import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '@/type';
+import { metrics as defaultMetrics } from '@/libs/metrics';
 
 export class Server {
   public options: ModernServerOptions;
@@ -23,9 +31,6 @@ export class Server {
 
   constructor(options: ModernServerOptions) {
     this.options = options;
-    options.plugins?.forEach(p => {
-      serverManager.usePlugin(p);
-    });
   }
 
   public getRequestHandler() {
@@ -41,38 +46,24 @@ export class Server {
 
   public async init() {
     const { options } = this;
-    this.runner = await serverManager.init({});
-
-    const { logger, measure } = await this.runner.create(
-      {
-        loggerOptions: options.logger,
-        measureOptions: options.measure,
-      },
-      { onLast: () => ({} as any) },
-    );
 
-    options.logger = options.logger || logger || defaultLogger;
-    options.measure = options.measure || measure || defaultMeasure;
+    options.logger = options.logger || defaultLogger;
+    options.metrics = options.metrics || defaultMetrics;
 
+    // initialize server
     if (options.dev) {
       this.server = this.createDevServer();
-
-      // check if https is configured when start dev server
-      const devHttpsOption =
-        typeof options.dev === 'object' && options.dev.https;
-      if (devHttpsOption) {
-        const { genHttpsOptions } = require('@/dev-tools/https');
-        const httpsOptions = await genHttpsOptions(devHttpsOption);
-        this.app = createHttpsServer(httpsOptions, this.getRequestHandler());
-      } else {
-        this.app = createServer(this.getRequestHandler());
-      }
     } else {
       this.server = this.createProdServer();
-      this.app = createServer(this.getRequestHandler());
     }
+    // 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);
 
-    await this.server.init();
     return this;
   }
 
@@ -103,28 +94,70 @@ export class Server {
     const { options } = this;
 
     if (options.apiOnly) {
-      const { APIModernServer } = require('./api-server');
-      return new APIModernServer(options, this.runner);
+      return new ModernAPIServer(options);
+    } else if (options.ssrOnly) {
+      return new ModernSSRServer(options);
     } else if (options.webOnly) {
-      const { WebModernServer } = require('./web-server');
-      return new WebModernServer(options, this.runner);
+      return new ModernWebServer(options);
     } else {
-      return new ModernServer(options, this.runner);
+      return new ModernServer(options);
     }
   }
 
   private createDevServer() {
     const { options } = this;
+    const {
+      ModernAPIDevServer,
+      ModernSSRDevServer,
+      ModernDevServer,
+    } = require('./dev-server');
 
     if (options.apiOnly) {
-      const { APIModernDevServer } = require('./api-server');
-      return new APIModernDevServer(options, this.runner);
-    } else if (options.webOnly) {
-      const { WebModernDevServer } = require('./web-server');
-      return new WebModernDevServer(options, this.runner);
+      return new ModernAPIDevServer(options);
+    } else if (options.ssrOnly) {
+      return new ModernSSRDevServer(options);
     } else {
-      const { ModernDevServer } = require('./dev-server');
-      return new ModernDevServer(options, this.runner);
+      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

@@ -0,0 +1,97 @@
+import { APIServerStartInput } from '@modern-js/server-plugin';
+import { ModernServer } from './modern-server';
+import { mergeExtension } from '@/utils';
+import { ModernRoute, ModernRouteInterface, RouteMatcher } from '@/libs/route';
+import { ApiServerMode } from '@/constants';
+import { ModernServerContext } from '@/libs/context';
+
+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);
+    }
+  }
+}

package/src/server/modern-server.ts

@@ -1,10 +1,10 @@
 /* eslint-disable max-lines */
-import { IncomingMessage, ServerResponse, Server } from 'http';
+import { IncomingMessage, ServerResponse, Server, createServer } from 'http';
 import util from 'util';
 import path from 'path';
 import { fs, ROUTE_SPEC_FILE } from '@modern-js/utils';
-import { Adapter } from '@modern-js/server-plugin';
-import { gather, createMiddlewareCollecter } from '@modern-js/server-utils';
+import { Adapter, APIServerStartInput } from '@modern-js/server-plugin';
+import { createMiddlewareCollecter } from '@modern-js/server-utils';
 import type { NormalizedConfig } from '@modern-js/core';
 import mime from 'mime-types';
 import axios from 'axios';
@@ -12,17 +12,22 @@ import {
   ModernServerOptions,
   NextFunction,
   ServerHookRunner,
-  Measure,
+  Metrics,
   Logger,
   ReadyOptions,
   ConfWithBFF,
-} from '../type';
-import { RouteMatchManager, ModernRouteInterface } from '../libs/route';
-import { createRenderHandler } from '../libs/render';
-import { createStaticFileHandler } from '../libs/serve-file';
-import { createErrorDocument, mergeExtension, noop } from '../utils';
-import * as reader from '../libs/render/reader';
-import { createProxyHandler, ProxyOptions } from '../libs/proxy';
+} from '@/type';
+import {
+  RouteMatchManager,
+  ModernRouteInterface,
+  ModernRoute,
+  RouteMatcher,
+} from '@/libs/route';
+import { createRenderHandler } from '@/libs/render';
+import { createStaticFileHandler } from '@/libs/serve-file';
+import { createErrorDocument, mergeExtension, noop } from '@/utils';
+import * as reader from '@/libs/render/reader';
+import { createProxyHandler, ProxyOptions } from '@/libs/proxy';
 import { createContext, ModernServerContext } from '@/libs/context';
 import {
   AGGRED_DIR,
@@ -30,7 +35,8 @@ import {
   ERROR_DIGEST,
   ERROR_PAGE_TEXT,
 } from '@/constants';
-import { createTemplateAPI } from '@/libs/hook-api';
+import { createTemplateAPI } from '@/libs/hook-api/template';
+import { createRouteAPI } from '@/libs/hook-api/route';
 
 type ModernServerHandler = (
   context: ModernServerContext,
@@ -63,11 +69,13 @@ export class ModernServer {
 
   protected presetRoutes?: ModernRouteInterface[];
 
+  protected runner!: ServerHookRunner;
+
   protected readonly logger: Logger;
 
-  protected readonly measure: Measure;
+  protected readonly metrics: Metrics;
 
-  private readonly runner: ServerHookRunner;
+  protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
 
   private readonly isDev: boolean = false;
 
@@ -85,30 +93,28 @@ export class ModernServer {
 
   private proxyHandler: ReturnType<typeof createProxyHandler> = null;
 
-  constructor(
-    {
-      pwd,
-      config,
-      dev,
-      routes,
-      staticGenerate,
-      logger,
-      measure,
-    }: ModernServerOptions,
-    runner: ServerHookRunner,
-  ) {
+  constructor({
+    pwd,
+    config,
+    dev,
+    routes,
+    staticGenerate,
+    logger,
+    metrics,
+    proxyTarget,
+  }: ModernServerOptions) {
     require('ignore-styles');
     this.isDev = Boolean(dev);
 
     this.pwd = pwd;
-    this.distDir = path.join(pwd, config.output.path || '');
+    this.distDir = path.join(pwd, config.output.path || 'dist');
     this.workDir = this.isDev ? pwd : this.distDir;
     this.conf = config;
-    this.runner = runner;
     this.logger = logger!;
-    this.measure = measure!;
+    this.metrics = metrics!;
     this.router = new RouteMatchManager();
     this.presetRoutes = routes;
+    this.proxyTarget = proxyTarget;
 
     if (staticGenerate) {
       this.staticGenerate = staticGenerate;
@@ -122,7 +128,9 @@ export class ModernServer {
   }
 
   // server prepare
-  public async init() {
+  public async init(runner: ServerHookRunner) {
+    this.runner = runner;
+
     const { distDir, isDev, staticGenerate, conf } = this;
 
     this.addHandler((ctx: ModernServerContext, next: NextFunction) => {
@@ -198,16 +206,14 @@ export class ModernServer {
     reader.close();
   }
 
-  // warmup ssr function
-  protected warmupSSRBundle() {
-    const { distDir } = this;
-    const bundles = this.router.getBundles();
-
-    bundles.forEach(bundle => {
-      const filepath = path.join(distDir, bundle!);
-      // if error, just throw and let process die
-      require(filepath);
-    });
+  public async createHTTPServer(
+    handler: (
+      req: IncomingMessage,
+      res: ServerResponse,
+      next?: () => void,
+    ) => void,
+  ) {
+    return createServer(handler);
   }
 
   // read route spec from route.json
@@ -239,14 +245,7 @@ export class ModernServer {
 
   // gather frame extension and get framework handler
   protected async prepareFrameHandler() {
-    const { workDir, runner, conf } = this;
-
-    // inner tool, gather user inject
-    let userAPIExt = [];
-    let userWebExt = [];
-    if (!conf.server.disableUserExtension) {
-      ({ api: userAPIExt, web: userWebExt } = gather(workDir));
-    }
+    const { workDir, runner } = this;
 
     // server hook, gather plugin inject
     const { getMiddlewares, ...collector } = createMiddlewareCollecter();
@@ -259,7 +258,7 @@ export class ModernServer {
 
     // get api or web server handler from server-framework plugin
     if (await fs.pathExists(path.join(serverDir))) {
-      const webExtension = mergeExtension(pluginWebExt, userWebExt);
+      const webExtension = mergeExtension(pluginWebExt);
       this.frameWebHandler = await this.prepareWebHandler(webExtension);
     }
 
@@ -269,14 +268,16 @@ export class ModernServer {
         : ApiServerMode.func;
 
       // if use lambda/, mean framework style of writing, then discard user extension
-      const apiExtension = mergeExtension(
-        pluginAPIExt,
-        mode === ApiServerMode.frame ? [] : userAPIExt,
-      );
+      const apiExtension = mergeExtension(pluginAPIExt);
       this.frameAPIHandler = await this.prepareAPIHandler(mode, apiExtension);
     }
   }
 
+  // Todo
+  protected async proxy() {
+    return null as any;
+  }
+
   /* —————————————————————— function will be overwrite —————————————————————— */
   protected async prepareWebHandler(
     extension: ReturnType<typeof mergeExtension>,
@@ -294,7 +295,7 @@ export class ModernServer {
 
   protected async prepareAPIHandler(
     mode: ApiServerMode,
-    extension: ReturnType<typeof mergeExtension>,
+    extension: APIServerStartInput['config'],
   ) {
     const { workDir, runner, conf } = this;
     const { bff } = conf as ConfWithBFF;
@@ -305,7 +306,7 @@ export class ModernServer {
         pwd: workDir,
         mode,
         config: extension,
-        prefix,
+        prefix: Array.isArray(prefix) ? prefix[0] : prefix,
       },
       { onLast: () => null as any },
     );
@@ -315,62 +316,89 @@ export class ModernServer {
     return routes;
   }
 
+  protected async emitRouteHook(
+    eventName: 'beforeMatch' | 'afterMatch' | 'beforeRender' | 'afterRender',
+    input: any,
+  ) {
+    return this.runner[eventName](input, { onLast: noop as any });
+  }
+
+  // warmup ssr function
+  protected warmupSSRBundle() {
+    const { distDir } = this;
+    const bundles = this.router.getBundles();
+
+    bundles.forEach(bundle => {
+      const filepath = path.join(distDir, bundle as string);
+      // if error, just throw and let process die
+      require(filepath);
+    });
+  }
+
   protected async preServerInit() {
-    const { conf } = this;
+    const { conf, runner } = this;
     const preMiddleware: ModernServerAsyncHandler[] =
-      await this.runner.preServerInit(conf);
+      await runner.preServerInit(conf);
 
-    preMiddleware.forEach(mid => {
+    preMiddleware.flat().forEach(mid => {
       this.addHandler(mid);
     });
   }
 
-  private prepareFavicons(
-    favicon: string | undefined,
-    faviconByEntries?: Record<string, string | undefined>,
-  ) {
-    const faviconNames = [];
-    if (favicon) {
-      faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
-    }
-    if (faviconByEntries) {
-      Object.keys(faviconByEntries).forEach(f => {
-        const curFavicon = faviconByEntries[f];
-        if (curFavicon) {
-          faviconNames.push(
-            curFavicon.substring(curFavicon.lastIndexOf('/') + 1),
-          );
-        }
-      });
+  protected async handleAPI(context: ModernServerContext) {
+    const { req, res } = context;
+
+    if (!this.frameAPIHandler) {
+      throw new Error('can not found api hanlder');
     }
-    return faviconNames;
+
+    await this.frameAPIHandler(req, res);
   }
 
-  /* —————————————————————— private function —————————————————————— */
+  protected async handleWeb(context: ModernServerContext, route: ModernRoute) {
+    return this.routeRenderHandler(context, route);
+  }
+
+  protected verifyMatch(_c: ModernServerContext, _m: RouteMatcher) {
+    // empty
+  }
 
+  /* —————————————————————— private function —————————————————————— */
   // handler route.json, include api / csr / ssr
   // eslint-disable-next-line max-statements
   private async routeHandler(context: ModernServerContext) {
     const { req, res } = context;
 
+    await this.emitRouteHook('beforeMatch', { context });
+
     // match routes in the route spec
     const matched = this.router.match(context.url);
     if (!matched) {
       this.render404(context);
       return;
+    } else {
+      this.verifyMatch(context, matched);
+    }
+
+    if (res.headersSent) {
+      return;
     }
 
-    const route = matched.generate();
-    const params = matched.parseURLParams(context.url);
+    const routeAPI = createRouteAPI(matched, this.router);
+    await this.emitRouteHook('afterMatch', { context, routeAPI });
+
+    if (res.headersSent) {
+      return;
+    }
+
+    const { current } = routeAPI as any;
+    const route: ModernRoute = current.generate();
+    const params = current.parseURLParams(context.url);
     context.setParams(params);
 
     // route is api service
     if (route.isApi) {
-      if (!this.frameAPIHandler) {
-        throw new Error('can not found api hanlder');
-      }
-
-      await this.frameAPIHandler(req, res);
+      this.handleAPI(context);
       return;
     }
 
@@ -383,7 +411,11 @@ export class ModernServer {
       return;
     }
 
-    const file = await this.routeRenderHandler(context, route);
+    if (route.entryName) {
+      await this.emitRouteHook('beforeRender', { context });
+    }
+
+    const file = await this.handleWeb(context, route);
     if (!file) {
       this.render404(context);
       return;
@@ -399,10 +431,7 @@ export class ModernServer {
     let response = file.content;
     if (route.entryName) {
       const templateAPI = createTemplateAPI(file.content.toString());
-      await this.runner.afterRender(
-        { context, templateAPI },
-        { onLast: noop as any },
-      );
+      await this.emitRouteHook('afterRender', { context, templateAPI });
       await this.injectMicroFE(context, templateAPI);
       response = templateAPI.get();
     }
@@ -519,7 +548,7 @@ export class ModernServer {
     res.statusCode = 200;
     const context: ModernServerContext = createContext(req, res, {
       logger: this.logger,
-      measure: this.measure,
+      metrics: this.metrics,
     });
 
     try {
@@ -565,5 +594,26 @@ export class ModernServer {
     const text = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT[500];
     res.end(createErrorDocument(status, text));
   }
+
+  private prepareFavicons(
+    favicon: string | undefined,
+    faviconByEntries?: Record<string, string | undefined>,
+  ) {
+    const faviconNames = [];
+    if (favicon) {
+      faviconNames.push(favicon.substring(favicon.lastIndexOf('/') + 1));
+    }
+    if (faviconByEntries) {
+      Object.keys(faviconByEntries).forEach(f => {
+        const curFavicon = faviconByEntries[f];
+        if (curFavicon) {
+          faviconNames.push(
+            curFavicon.substring(curFavicon.lastIndexOf('/') + 1),
+          );
+        }
+      });
+    }
+    return faviconNames;
+  }
 }
 /* eslint-enable max-lines */

package/src/type.ts

@@ -2,7 +2,7 @@ import { Buffer } from 'buffer';
 import type Webpack from 'webpack';
 import { serverManager } from '@modern-js/server-plugin';
 import type { NormalizedConfig } from '@modern-js/core';
-import type { Measure, Logger, NextFunction } from '@modern-js/types/server';
+import type { Metrics, Logger, NextFunction } from '@modern-js/types/server';
 import { ModernRouteInterface } from './libs/route';
 
 declare module '@modern-js/core' {
@@ -45,11 +45,16 @@ export type ModernServerOptions = {
   staticGenerate?: boolean;
   customServer?: boolean;
   loggerOptions?: Record<string, string>;
-  measureOptions?: Record<string, string>;
+  metricsOptions?: Record<string, string>;
   logger?: Logger;
-  measure?: Measure;
+  metrics?: Metrics;
   apiOnly?: boolean;
+  ssrOnly?: boolean;
   webOnly?: boolean;
+  proxyTarget?: {
+    ssr?: string;
+    api?: string;
+  };
 };
 
 export type RenderResult = {
@@ -71,4 +76,4 @@ export type ServerHookRunner = Then<ReturnType<typeof serverManager.init>>;
 
 export type ReadyOptions = { routes?: ModernRouteInterface[] };
 
-export type { Measure, Logger, NextFunction };
+export type { Metrics, Logger, NextFunction };