@modern-js/prod-server 1.0.1 → 1.0.3

package/CHANGELOG.md

@@ -1,6 +1,23 @@
 # @modern-js/prod-server
 
+## 1.0.2
+
+### Patch Changes
+
+- a78e32d8: remove server hook when api only
+- e11eaafc: fix runner error in dev
+- cbba492b: add serverless pre-render unit-test
+- 59010b7a: rewrite server lifecycle, add unit test
+- Updated dependencies [cc5e8001]
+- Updated dependencies [2520ea86]
+- Updated dependencies [db43dce6]
+- Updated dependencies [e81fd9b7]
+- Updated dependencies [1c411e71]
+  - @modern-js/core@1.4.6
+  - @modern-js/utils@1.3.4
+
 ## 1.0.1
+
 ### Patch Changes
 
 - 02fb4146: support product server

package/dist/js/modern/constants.js

@@ -23,4 +23,8 @@ export const ERROR_DIGEST = {
 export const ERROR_PAGE_TEXT = {
   404: 'This page could not be found.',
   500: 'Internal Server Error.'
+};
+export const RUN_MODE = {
+  FULL: 'full',
+  TYPE: 'type'
 };

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

@@ -5,7 +5,9 @@ import { NativeModuleNameMap } from "./browser-list";
 const nativeModules = require('@babel/compat-data/native-modules');
 
 export const supportModern = context => {
-  if (context.query.modern_es6) {
+  var _context$query;
+
+  if ((_context$query = context.query) !== null && _context$query !== void 0 && _context$query.modern_es6) {
     return true;
   } // no ua in request headers
 

package/dist/js/modern/server/index.js

@@ -6,24 +6,9 @@ function _defineProperty(obj, key, value) { if (key in obj) { Object.definePrope
 
 import path from 'path';
 import { serverManager, AppContext, ConfigContext } from '@modern-js/server-core';
-import { compatRequire, logger as defaultLogger } from '@modern-js/utils';
-import { initAppContext, initAppDir, loadUserConfig } from '@modern-js/core';
+import { compatRequire, logger as defaultLogger, SHARED_DIR } from '@modern-js/utils';
 import { metrics as defaultMetrics } from "../libs/metrics";
-import { ModernServer } from "./modern-server";
-import { ModernAPIServer, ModernSSRServer, ModernWebServer } from "./modern-server-split";
-
-const createProdServer = options => {
-  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);
-  }
-};
-
+import { createProdServer } from "./modern-server-split";
 export class Server {
   constructor(options) {
     this.options = void 0;
@@ -31,68 +16,64 @@ export class Server {
     this.server = void 0;
     this.app = void 0;
     this.runner = void 0;
+    options.logger = options.logger || defaultLogger;
+    options.metrics = options.metrics || defaultMetrics;
     this.options = options;
   }
 
-  getRequestHandler() {
-    return (req, res, next) => {
-      const requestHandler = this.server.getRequestHandler();
-      return requestHandler(req, res, next);
-    };
-  }
-
-  ready(readyOptions = {}) {
-    this.server.ready(readyOptions);
-  }
-
   async init() {
     const {
       options
-    } = this;
-    options.logger = options.logger || defaultLogger;
-    options.metrics = options.metrics || defaultMetrics; // initialize server
+    } = this; // initialize server
 
     this.server = this.serverImpl(options); // create http-server
 
-    this.app = await this.server.createHTTPServer(this.getRequestHandler());
+    this.app = await this.server.createHTTPServer(this.getRequestHandler()); // initialize server runner
+
     this.runner = await this.createHookRunner(); // runner can only be used after server init
 
-    await this.server.init(this.runner);
+    await this.server.onInit(this.runner);
     return this;
   }
 
+  async close() {
+    await this.server.onClose();
+    await new Promise(resolve => this.app.close(() => {
+      resolve();
+    }));
+  }
+
   listen(port = 8080, listener) {
     this.app.listen(process.env.PORT || port, () => {
       if (listener) {
         listener();
       }
 
-      this.listener(this.app);
+      this.server.onListening(this.app);
     });
   }
 
-  listener(app) {
-    this.server.onListening(app);
-  }
-
-  async close() {
-    await this.server.close();
-    await new Promise(resolve => this.app.close(() => {
-      resolve();
-    }));
+  getRequestHandler() {
+    return (req, res, next) => {
+      const requestHandler = this.server.getRequestHandler();
+      return requestHandler(req, res, next);
+    };
   }
 
   async createHookRunner() {
-    var _options$plugins;
-
+    // clear server manager every create time
+    serverManager.clear();
     const {
       options
     } = this;
-    serverManager.clear();
-    (_options$plugins = options.plugins) === null || _options$plugins === void 0 ? void 0 : _options$plugins.forEach(p => {
+    const {
+      plugins = []
+    } = options; // server app context for serve plugin
+
+    plugins.forEach(p => {
       serverManager.usePlugin(compatRequire(p.pluginPath));
     });
-    const appContext = await this.initAppContext();
+    const appContext = this.initAppContext();
     serverManager.run(() => {
       var _options$config$outpu;
 
@@ -104,17 +85,26 @@ export class Server {
     return serverManager.init({});
   }
 
-  async initAppContext() {
-    var _this$options$plugins;
+  initAppContext() {
+    var _config$output;
 
-    const appDirectory = await initAppDir();
-    const loaded = await loadUserConfig(appDirectory);
-    const plugins = (_this$options$plugins = this.options.plugins) === null || _this$options$plugins === void 0 ? void 0 : _this$options$plugins.map(p => ({
-      server: p,
-      cli: undefined
+    const {
+      options
+    } = this;
+    const {
+      pwd: appDirectory,
+      plugins = [],
+      config
+    } = options;
+    const serverPlugins = plugins.map(p => ({
+      server: p
     }));
-    const appContext = initAppContext(appDirectory, plugins || [], loaded.filePath);
-    return appContext;
+    return {
+      appDirectory,
+      distDirectory: path.join(appDirectory, ((_config$output = config.output) === null || _config$output === void 0 ? void 0 : _config$output.path) || 'dist'),
+      sharedDirectory: path.resolve(appDirectory, SHARED_DIR),
+      plugins: serverPlugins
+    };
   }
 
 }

package/dist/js/modern/server/modern-server-split.js

@@ -1,55 +1,52 @@
+import { RUN_MODE } from "../constants";
 import { ModernServer } from "./modern-server";
-export class ModernSSRServer extends ModernServer {
-  // Todo should not invoke any route hook in modernSSRServer
-  async warmupSSRBundle() {// empty
-  }
-
-  verifyMatch(context, matched) {
-    if (matched.generate(context.url).isApi) {
-      this.render404(context);
-    }
-  }
 
+class ModernSSRServer extends ModernServer {
   prepareAPIHandler(_m, _) {
     return null;
   }
 
-  async prepareWebHandler(extension) {
-    return super.prepareWebHandler(extension);
-  } // protected filterRoutes(routes: ModernRouteInterface[]) {
-  //   return routes.filter(route => route.entryName);
-  // }
-
-
-  async preServerInit() {// empty
+  filterRoutes(routes) {
+    return routes.filter(route => route.isSSR);
   }
 
-}
-export class ModernAPIServer extends ModernServer {
-  async emitRouteHook(_, _input) {// empty
+  async preServerInit() {
+    if (this.runMode === RUN_MODE.FULL) {
+      await super.preServerInit();
+    }
   }
 
-  async warmupSSRBundle() {// empty
+  async emitRouteHook(_, _input) {
+    if (this.runMode === RUN_MODE.FULL) {
+      await super.emitRouteHook(_, _input);
+    }
   }
 
+}
+
+class ModernAPIServer extends ModernServer {
   prepareWebHandler(_) {
     return null;
   }
 
-  async prepareAPIHandler(mode, extension) {
-    return super.prepareAPIHandler(mode, extension);
-  }
-
   filterRoutes(routes) {
     return routes.filter(route => route.isApi);
   }
 
-  async preServerInit() {// empty
+  async preServerInit() {
+    if (this.runMode === RUN_MODE.FULL) {
+      await super.preServerInit();
+    }
+  }
+
+  async emitRouteHook(_, _input) {// empty
   }
 
 }
-export class ModernWebServer extends ModernServer {
-  async warmupSSRBundle() {// empty
+
+class ModernWebServer extends ModernServer {
+  async warmupSSRBundle() {
+    return null;
   }
 
   async handleAPI(context) {
@@ -57,10 +54,10 @@ export class ModernWebServer extends ModernServer {
       proxyTarget
     } = this;
 
-    if (!(proxyTarget !== null && proxyTarget !== void 0 && proxyTarget.api)) {
-      this.proxy();
+    if (proxyTarget !== null && proxyTarget !== void 0 && proxyTarget.api) {
+      return this.proxy();
     } else {
-      this.render404(context);
+      return this.render404(context);
     }
   }
 
@@ -78,4 +75,16 @@ export class ModernWebServer extends ModernServer {
     }
   }
 
-}
+}
+
+export const createProdServer = options => {
+  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);
+  }
+};

package/dist/js/modern/server/modern-server.js

@@ -25,7 +25,7 @@ import { createErrorDocument, createMiddlewareCollecter, getStaticReg, mergeExte
 import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
-import { AGGRED_DIR, ApiServerMode, ERROR_DIGEST, ERROR_PAGE_TEXT } from "../constants";
+import { AGGRED_DIR, ApiServerMode, ERROR_DIGEST, ERROR_PAGE_TEXT, RUN_MODE } from "../constants";
 import { createTemplateAPI } from "../libs/hook-api/template";
 import { createRouteAPI } from "../libs/hook-api/route";
 const API_DIR = './api';
@@ -41,6 +41,7 @@ export class ModernServer {
     staticGenerate,
     logger,
     metrics,
+    runMode,
     proxyTarget
   }) {
     var _config$output;
@@ -55,6 +56,7 @@ export class ModernServer {
     this.runner = void 0;
     this.logger = void 0;
     this.metrics = void 0;
+    this.runMode = void 0;
     this.reader = reader;
     this.proxyTarget = void 0;
     this.staticFileHandler = void 0;
@@ -63,7 +65,7 @@ export class ModernServer {
     this.frameAPIHandler = null;
     this.proxyHandler = null;
     this._handler = void 0;
-    this.staticGenerate = false;
+    this.staticGenerate = void 0;
 
     require('ignore-styles');
 
@@ -76,21 +78,13 @@ export class ModernServer {
     this.router = new RouteMatchManager();
     this.presetRoutes = routes;
     this.proxyTarget = proxyTarget;
-
-    if (staticGenerate) {
-      this.staticGenerate = staticGenerate;
-    }
-
+    this.staticGenerate = staticGenerate || false;
+    this.runMode = runMode || RUN_MODE.TYPE;
     process.env.BUILD_TYPE = `${this.staticGenerate ? 'ssg' : 'ssr'}`;
-  } // exposed requestHandler
-
-
-  getRequestHandler() {
-    return this.requestHandler.bind(this);
   } // server prepare
 
 
-  async init(runner) {
+  async onInit(runner) {
     var _conf$bff;
 
     this.runner = runner;
@@ -98,7 +92,8 @@ export class ModernServer {
       distDir,
       staticGenerate,
       conf
-    } = this;
+    } = this; // Todo: why add this middleware
+
     this.addHandler((ctx, next) => {
       ctx.res.setHeader('Access-Control-Allow-Origin', '*');
       ctx.res.setHeader('Access-Control-Allow-Credentials', 'false');
@@ -111,12 +106,14 @@ export class ModernServer {
       this.proxyHandler.forEach(handler => {
         this.addHandler(handler);
       });
-    } // start reader, include an time interval
+    } // start file reader
 
 
     this.reader.init(); // use preset routes priority
 
-    this.router.reset(this.filterRoutes(this.presetRoutes || this.readRouteSpec()));
+    const usageRoutes = this.filterRoutes(this.getRoutes());
+    this.router.reset(usageRoutes); // warmup ssr bundle in production env
+
     this.warmupSSRBundle();
     await this.prepareFrameHandler(); // Only work when without setting `assetPrefix`.
     // Setting `assetPrefix` means these resources should be uploaded to CDN.
@@ -132,29 +129,47 @@ export class ModernServer {
     });
     await this.preServerInit();
     this.addHandler(this.staticFileHandler);
-    this.addHandler(this.routeHandler.bind(this));
+    this.addHandler(this.routeHandler.bind(this)); // compose middlewares to http handler
+
     this.compose();
+  } // close any thing run in server
+
+
+  async onClose() {
+    this.reader.close();
   } // server ready
-  // eslint-disable-next-line @typescript-eslint/no-empty-function
 
 
-  ready(_) {} // invoke when http server listen
+  onRepack(_) {// empty
+  } // invoke when http server listen
 
 
   onListening(_) {// empty
-  } // close any thing run in server
+  }
 
+  onServerChange(_) {
+    this.prepareFrameHandler();
+  } // exposed requestHandler
 
-  async close() {
-    this.reader.close();
+
+  getRequestHandler() {
+    return this.requestHandler.bind(this);
   }
 
   async createHTTPServer(handler) {
     return createServer(handler);
-  } // read route spec from route.json
+  }
+  /* —————————————————————— function will be overwrite —————————————————————— */
+  // get routes info
+
+
+  getRoutes() {
+    // Preferred to use preset routes
+    if (this.presetRoutes) {
+      return this.presetRoutes;
+    } // read routes from spec file
 
 
-  readRouteSpec() {
     const file = path.join(this.distDir, ROUTE_SPEC_FILE);
 
     if (fs.existsSync(file)) {
@@ -213,14 +228,7 @@ export class ModernServer {
       const apiExtension = mergeExtension(pluginAPIExt);
       this.frameAPIHandler = await this.prepareAPIHandler(mode, apiExtension);
     }
-  } // Todo
-
-
-  async proxy() {
-    return null;
   }
-  /* —————————————————————— function will be overwrite —————————————————————— */
-
 
   async prepareWebHandler(extension) {
     const {
@@ -264,19 +272,6 @@ export class ModernServer {
     return this.runner[eventName](input, {
       onLast: noop
     });
-  } // warmup ssr function
-
-
-  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);
-    });
   }
 
   async preServerInit() {
@@ -311,7 +306,21 @@ export class ModernServer {
     });
   }
 
-  verifyMatch(_c, _m) {// empty
+  async proxy() {
+    return null;
+  } // warmup ssr function
+
+
+  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);
+    });
   }
   /* —————————————————————— private function —————————————————————— */
   // handler route.json, include api / csr / ssr
@@ -332,8 +341,6 @@ export class ModernServer {
     if (!matched) {
       this.render404(context);
       return;
-    } else {
-      this.verifyMatch(context, matched);
     }
 
     if (res.headersSent) {
@@ -569,7 +576,7 @@ export class ModernServer {
     }
 
     const text = ERROR_PAGE_TEXT[status] || ERROR_PAGE_TEXT[500];
-    res.end(createErrorDocument(status, text));
+    context.res.end(createErrorDocument(status, text));
   }
 
 }

package/dist/js/modern/type.js

@@ -1 +1 @@
-export {};
+import { IncomingMessage } from 'http';

package/dist/js/node/constants.js

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
-exports.ERROR_PAGE_TEXT = exports.ERROR_DIGEST = exports.ApiServerMode = exports.AGGRED_DIR = void 0;
+exports.RUN_MODE = exports.ERROR_PAGE_TEXT = exports.ERROR_DIGEST = exports.ApiServerMode = exports.AGGRED_DIR = void 0;
 const AGGRED_DIR = {
   mock: 'config/mock',
   server: 'server',
@@ -33,4 +33,9 @@ const ERROR_PAGE_TEXT = {
   404: 'This page could not be found.',
   500: 'Internal Server Error.'
 };
-exports.ERROR_PAGE_TEXT = ERROR_PAGE_TEXT;
+exports.ERROR_PAGE_TEXT = ERROR_PAGE_TEXT;
+const RUN_MODE = {
+  FULL: 'full',
+  TYPE: 'type'
+};
+exports.RUN_MODE = RUN_MODE;

package/dist/js/node/libs/render/modern/index.js

@@ -16,7 +16,9 @@ function _interopRequireDefault(obj) { return obj && obj.__esModule ? obj : { de
 const nativeModules = require('@babel/compat-data/native-modules');
 
 const supportModern = context => {
-  if (context.query.modern_es6) {
+  var _context$query;
+
+  if ((_context$query = context.query) !== null && _context$query !== void 0 && _context$query.modern_es6) {
     return true;
   } // no ua in request headers