@modern-js/server 1.1.2 → 1.1.3-beta.0

package/dist/types/server/{api-server.d.ts → dev-server/dev-server-split.d.ts}

@@ -1,13 +1,12 @@
+import type { APIServerStartInput } from '@modern-js/server-plugin';
 import { ModernDevServer } from './dev-server';
-import { ModernServer } from './modern-server';
-import { mergeExtension } from "../utils.d";
-import { ModernRouteInterface } from "../libs/route";
-import { ApiServerMode } from "../constants.d";
-export declare class APIModernServer extends ModernServer {
-  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>): any;
-  protected prepareAPIHandler(mode: ApiServerMode, extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
+import { mergeExtension } from "../../utils.d";
+import { ModernRouteInterface } from "../../libs/route";
+import { ApiServerMode } from "../../constants.d";
+export declare class WebModernDevServer extends ModernDevServer {
+  protected prepareAPIHandler(_m: ApiServerMode, _: APIServerStartInput['config']): any;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
   protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
-  protected preServerInit(): Promise<void>;
 }
 export declare class APIModernDevServer extends ModernDevServer {
   protected prepareWebHandler(_: ReturnType<typeof mergeExtension>): any;

package/dist/types/server/{dev-server.d.ts → dev-server/dev-server.d.ts}

@@ -1,7 +1,7 @@
 /// <reference types="node" />
-import { Server } from 'http';
-import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '../type';
-import { ModernServer } from './modern-server';
+import http, { Server, IncomingMessage, ServerResponse } from 'http';
+import { ModernServer } from '../modern-server';
+import { ModernServerOptions, ServerHookRunner, ReadyOptions } from "../../type.d";
 export declare class ModernDevServer extends ModernServer {
   private devProxyHandler;
   private mockHandler;
@@ -10,11 +10,12 @@ export declare class ModernDevServer extends ModernServer {
   private socketServer;
   private watcher;
   private devMiddleware;
-  constructor(options: ModernServerOptions, runner: ServerHookRunner);
-  init(): Promise<void>;
+  constructor(options: ModernServerOptions);
+  init(runner: ServerHookRunner): Promise<void>;
   ready(options?: ReadyOptions): void;
   onListening(app: Server): void;
   close(): Promise<void>;
+  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<http.Server | import("https").Server>;
   private setupCompiler;
   private setupDevServerPlugin;
   private setupHooks;

package/dist/types/server/dev-server/index.d.ts

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

package/dist/types/server/index.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server as httpServer } from 'http';
-import { ModernServerOptions, ReadyOptions } from '../type';
+import { ModernServerOptions, ReadyOptions } from "../type.d";
 export declare class Server {
   options: ModernServerOptions;
   private server;
@@ -15,4 +15,6 @@ export declare class Server {
   close(): Promise<void>;
   private createProdServer;
   private createDevServer;
+  private createHookRunner;
+  private initAppContext;
 }

package/dist/types/server/{web-server.d.ts → modern-server-split.d.ts}

@@ -1,4 +1,4 @@
-import { ModernDevServer } from './dev-server';
+import { APIServerStartInput } from '@modern-js/server-plugin';
 import { ModernServer } from './modern-server';
 import { mergeExtension } from "../utils.d";
 import { ModernRouteInterface } from "../libs/route";
@@ -8,8 +8,9 @@ export declare class WebModernServer extends ModernServer {
   protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
   protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
 }
-export declare class WebModernDevServer extends ModernDevServer {
-  protected prepareAPIHandler(_m: ApiServerMode, _: ReturnType<typeof mergeExtension>): any;
-  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
+export declare class APIModernServer extends ModernServer {
+  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>): any;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<import("@modern-js/server-plugin").Adapter>;
   protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
+  protected preServerInit(): Promise<void>;
 }

package/dist/types/server/modern-server.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server } from 'http';
-import { Adapter } from '@modern-js/server-plugin';
+import { Adapter, APIServerStartInput } from '@modern-js/server-plugin';
 import type { NormalizedConfig } from '@modern-js/core';
 import { ModernServerOptions, NextFunction, ServerHookRunner, Measure, Logger, ReadyOptions } from '../type';
 import { RouteMatchManager, ModernRouteInterface } from '../libs/route';
@@ -17,9 +17,9 @@ export declare class ModernServer {
   protected conf: NormalizedConfig;
   protected handlers: ModernServerAsyncHandler[];
   protected presetRoutes?: ModernRouteInterface[];
+  protected runner: ServerHookRunner;
   protected readonly logger: Logger;
   protected readonly measure: Measure;
-  private readonly runner;
   private readonly isDev;
   private staticFileHandler;
   private routeRenderHandler;
@@ -36,19 +36,20 @@ export declare class ModernServer {
     staticGenerate,
     logger,
     measure
-  }: ModernServerOptions, runner: ServerHookRunner);
+  }: ModernServerOptions);
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
-  init(): Promise<void>;
+  init(runner: ServerHookRunner): Promise<void>;
   ready(_: ReadyOptions): void;
   onListening(_: Server): void;
   close(): void;
+  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
   protected warmupSSRBundle(): void;
   protected readRouteSpec(): ModernRouteInterface[];
   protected addHandler(handler: ModernServerHandler): void;
   protected render404(context: ModernServerContext): void;
   protected prepareFrameHandler(): Promise<void>;
   protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
-  protected prepareAPIHandler(mode: ApiServerMode, extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<Adapter>;
   protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
   protected preServerInit(): Promise<void>;
   private prepareFavicons;

package/dist/types/utils.d.ts

@@ -1,4 +1,4 @@
-export declare const mergeExtension: (users: any[], plugins: any[]) => {
+export declare const mergeExtension: (users: any[]) => {
   middleware: any[];
 };
 export declare const toMessage: (dig: string, e: Error | string) => string;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.1.2",
+  "version": "1.1.3-beta.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -26,6 +26,14 @@
       "default": "./dist/js/treeshaking/index.js"
     }
   },
+  "scripts": {
+    "prepare": "pnpm build",
+    "prepublishOnly": "pnpm build --platform",
+    "new": "modern new",
+    "build": "modern build",
+    "dev": "modern build --watch",
+    "test": "modern test --passWithNoTests"
+  },
   "dependencies": {
     "@babel/core": "^7.15.0",
     "@babel/compat-data": "^7.15.0",
@@ -33,12 +41,12 @@
     "@babel/preset-typescript": "^7.15.0",
     "@babel/register": "^7.15.3",
     "@babel/runtime": "^7",
-    "@modern-js/core": "^1.1.2",
-    "@modern-js/hmr-client": "^1.1.1",
-    "@modern-js/server-plugin": "^1.1.1",
-    "@modern-js/server-utils": "^1.1.1",
-    "@modern-js/bff-utils": "^1.1.1",
-    "@modern-js/utils": "^1.1.2",
+    "@modern-js/core": "workspace:^1.1.2",
+    "@modern-js/hmr-client": "workspace:^1.1.1",
+    "@modern-js/server-plugin": "workspace:^1.1.1",
+    "@modern-js/server-utils": "workspace:^1.1.1",
+    "@modern-js/bff-utils": "workspace:^1.1.1",
+    "@modern-js/utils": "workspace:^1.1.2",
     "axios": "^0.21.4",
     "babel-plugin-module-resolver": "^4.1.0",
     "chokidar": "^3.5.2",
@@ -61,9 +69,9 @@
     "ws": "^8.2.0"
   },
   "devDependencies": {
-    "@modern-js/module-tools": "^1.1.0",
-    "@modern-js/plugin-testing": "^1.1.0",
-    "@modern-js/types": "^1.1.2",
+    "@modern-js/module-tools": "^1.1.1",
+    "@modern-js/plugin-testing": "^1.1.1",
+    "@modern-js/types": "workspace:^1.1.2",
     "@types/jest": "^26",
     "@types/lru-cache": "^5.1.1",
     "@types/mime-types": "^2.1.0",
@@ -92,11 +100,5 @@
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
     "access": "public"
-  },
-  "scripts": {
-    "new": "modern new",
-    "build": "modern build",
-    "dev": "modern build --watch",
-    "test": "modern test --passWithNoTests"
   }
-}
+}

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

@@ -0,0 +1,38 @@
+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/route/index.ts

@@ -60,6 +60,10 @@ export class RouteMatchManager {
     return best;
   }
 
+  public matchEntry(entryname: string) {
+    return this.matchers.find(matcher => matcher.matchEntry(entryname));
+  }
+
   public getBundles() {
     const bundles = this.specs
       .filter(route => route.isSSR)

package/src/libs/route/matcher.ts

@@ -75,6 +75,10 @@ export class RouteMatcher {
     }
   }
 
+  public matchEntry(entryName: string): boolean {
+    return this.spec.entryName === entryName;
+  }
+
   // compiler urlPath to regexp if necessary
   private setupUrlPath() {
     const { urlPath } = this.spec;

package/src/server/{api-server.ts → dev-server/dev-server-split.ts}

@@ -1,27 +1,25 @@
+import type { APIServerStartInput } from '@modern-js/server-plugin';
 import { ModernDevServer } from './dev-server';
-import { ModernServer } from './modern-server';
 import { mergeExtension } from '@/utils';
 import { ModernRouteInterface } from '@/libs/route';
 import { ApiServerMode } from '@/constants';
 
-export class APIModernServer extends ModernServer {
-  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>) {
+export class WebModernDevServer extends ModernDevServer {
+  protected prepareAPIHandler(
+    _m: ApiServerMode,
+    _: APIServerStartInput['config'],
+  ) {
     return null as any;
   }
 
-  protected async prepareAPIHandler(
-    mode: ApiServerMode,
+  protected async prepareWebHandler(
     extension: ReturnType<typeof mergeExtension>,
   ) {
-    return super.prepareAPIHandler(mode, extension);
+    return super.prepareWebHandler(extension);
   }
 
   protected filterRoutes(routes: ModernRouteInterface[]) {
-    return routes.filter(route => route.isApi);
-  }
-
-  protected async preServerInit() {
-    // noop
+    return routes.filter(route => route.entryName);
   }
 }
 

package/src/server/{dev-server.ts → dev-server/dev-server.ts}

@@ -1,27 +1,38 @@
-import http, { Server } from 'http';
+import http, {
+  Server,
+  createServer,
+  IncomingMessage,
+  ServerResponse,
+} from 'http';
 import path from 'path';
-import { HMR_SOCK_PATH } from '@modern-js/utils';
+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, {
   WebpackDevMiddleware,
 } from 'webpack-dev-middleware';
-import { createMockHandler } from '../dev-tools/mock';
-import { createProxyHandler, ProxyOptions } from '../libs/proxy';
+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 { ModernServer } from './modern-server';
+} 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 = {
@@ -57,8 +68,8 @@ export class ModernDevServer extends ModernServer {
       next: NextFunction,
     ) => void);
 
-  constructor(options: ModernServerOptions, runner: ServerHookRunner) {
-    super(options, runner);
+  constructor(options: ModernServerOptions) {
+    super(options);
 
     // set webpack compiler
     this.compiler = options.compiler!;
@@ -66,14 +77,14 @@ export class ModernDevServer extends ModernServer {
     // set dev server options, like webpack-dev-server
     this.dev =
       typeof options.dev === 'boolean' ? DEFAULT_DEV_OPTIONS : options.dev!;
+
+    enableRegister(this.pwd, this.conf);
   }
 
   // Complete the preparation of services
-  public async init() {
+  public async init(runner: ServerHookRunner) {
     const { conf, pwd, compiler } = this;
 
-    enableRegister(pwd, conf);
-
     // mock handler
     this.mockHandler = createMockHandler({ pwd });
     this.addHandler((ctx: ModernServerContext, next: NextFunction) => {
@@ -110,7 +121,7 @@ export class ModernDevServer extends ModernServer {
       this.addHandler(devMiddlewareHandler);
     }
 
-    await super.init();
+    await super.init(runner);
 
     // watch mock/ server/ api/ dir file change
     this.startWatcher();
@@ -125,6 +136,8 @@ export class ModernDevServer extends ModernServer {
 
     // reset static file
     reader.updateFile();
+
+    this.runner.reset();
   }
 
   public onListening(app: Server) {
@@ -141,6 +154,24 @@ export class ModernDevServer extends ModernServer {
     });
   }
 
+  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
@@ -217,12 +248,12 @@ export class ModernDevServer extends ModernServer {
 
   private startWatcher() {
     const { pwd } = this;
-    const { mock, server, api, shared } = AGGRED_DIR;
+    const { mock } = AGGRED_DIR;
     const defaultWatched = [
       `${pwd}/${mock}/**/*`,
-      `${pwd}/${server}/**/*`,
-      `${pwd}/${api}/**/*`,
-      `${pwd}/${shared}/**/*`,
+      `${pwd}/${SERVER_DIR}/**/*`,
+      `${pwd}/${API_DIR}/**/*`,
+      `${pwd}/${SHARED_DIR}/**/*`,
     ];
 
     const watcher = new Watcher();
@@ -233,6 +264,8 @@ export class ModernDevServer extends ModernServer {
       watcher.updateDepTree();
       watcher.cleanDepCache(filepath);
 
+      this.runner.reset();
+
       if (filepath.startsWith(`${pwd}/${mock}`)) {
         this.mockHandler = createMockHandler({ pwd });
       } else {

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

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

package/src/server/index.ts

@@ -1,15 +1,17 @@
-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,
+} from '@modern-js/core';
 import { ModernServer } from './modern-server';
 import type { ModernDevServer } from './dev-server';
+import { APIModernServer, WebModernServer } from './modern-server-split';
+import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '@/type';
 import { measure as defaultMeasure } from '@/libs/measure';
 
 export class Server {
@@ -23,9 +25,6 @@ export class Server {
 
   constructor(options: ModernServerOptions) {
     this.options = options;
-    options.plugins?.forEach(p => {
-      serverManager.usePlugin(p);
-    });
   }
 
   public getRequestHandler() {
@@ -41,38 +40,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.measure = options.measure || defaultMeasure;
 
+    // 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 +88,66 @@ export class Server {
     const { options } = this;
 
     if (options.apiOnly) {
-      const { APIModernServer } = require('./api-server');
-      return new APIModernServer(options, this.runner);
+      return new APIModernServer(options);
     } else if (options.webOnly) {
-      const { WebModernServer } = require('./web-server');
-      return new WebModernServer(options, this.runner);
+      return new WebModernServer(options);
     } else {
-      return new ModernServer(options, this.runner);
+      return new ModernServer(options);
     }
   }
 
   private createDevServer() {
     const { options } = this;
+    const {
+      APIModernDevServer,
+      WebModernDevServer,
+      ModernDevServer,
+    } = require('./dev-server');
 
     if (options.apiOnly) {
-      const { APIModernDevServer } = require('./api-server');
-      return new APIModernDevServer(options, this.runner);
+      return new APIModernDevServer(options);
     } else if (options.webOnly) {
-      const { WebModernDevServer } = require('./web-server');
-      return new WebModernDevServer(options, this.runner);
+      return new WebModernDevServer(options);
     } else {
-      const { ModernDevServer } = require('./dev-server');
-      return new ModernDevServer(options, this.runner);
+      return new ModernDevServer(options);
     }
   }
+
+  private async createHookRunner() {
+    const { options } = this;
+    const appContext = await this.initAppContext();
+    serverManager.run(() => {
+      AppContext.set({
+        ...appContext,
+        distDirectory: path.join(
+          options.pwd,
+          options.config.output.path || 'dist',
+        ),
+      });
+    });
+
+    options.plugins?.forEach(p => {
+      serverManager.usePlugin(p);
+    });
+
+    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/{web-server.ts → modern-server-split.ts}

@@ -1,4 +1,4 @@
-import { ModernDevServer } from './dev-server';
+import { APIServerStartInput } from '@modern-js/server-plugin';
 import { ModernServer } from './modern-server';
 import { mergeExtension } from '@/utils';
 import { ModernRouteInterface } from '@/libs/route';
@@ -23,21 +23,23 @@ export class WebModernServer extends ModernServer {
   }
 }
 
-export class WebModernDevServer extends ModernDevServer {
-  protected prepareAPIHandler(
-    _m: ApiServerMode,
-    _: ReturnType<typeof mergeExtension>,
-  ) {
+export class APIModernServer extends ModernServer {
+  protected prepareWebHandler(_: ReturnType<typeof mergeExtension>) {
     return null as any;
   }
 
-  protected async prepareWebHandler(
-    extension: ReturnType<typeof mergeExtension>,
+  protected async prepareAPIHandler(
+    mode: ApiServerMode,
+    extension: APIServerStartInput['config'],
   ) {
-    return super.prepareWebHandler(extension);
+    return super.prepareAPIHandler(mode, extension);
   }
 
   protected filterRoutes(routes: ModernRouteInterface[]) {
-    return routes.filter(route => route.entryName);
+    return routes.filter(route => route.isApi);
+  }
+
+  protected async preServerInit() {
+    // noop
   }
 }