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

package/dist/types/dev-tools/mock/getMockData.d.ts

@@ -15,4 +15,5 @@ declare const createStaticDataHandler: (method: string, handler: Record<string,
 
 declare const _default: (filepath: string) => MockApi[];
 
-export default _default;
+export default _default;
+export declare const getMatched: (context: ModernServerContext, mockApiList: MockApi[]) => MockApi | undefined;

package/dist/types/dev-tools/socket-server.d.ts

@@ -1,6 +1,5 @@
 /// <reference types="node" />
 import { Server } from 'http';
-import ws from 'ws';
 import type { Stats } from 'webpack';
 import { DevServerOptions } from '../type';
 export default class SocketServer {
@@ -13,7 +12,7 @@ export default class SocketServer {
   prepare(app: Server): void;
   updateStats(stats: Stats): void;
   sockWrite(type: string, data?: Record<string, any> | string | boolean): void;
-  close(connection: ws): void;
+  close(): void;
   private getStats;
   private sendStats;
   private send;

package/dist/types/dev-tools/watcher/index.d.ts

@@ -1,4 +1,5 @@
-import { WatchOptions } from 'chokidar';
+import chokidar, { FSWatcher, WatchOptions } from 'chokidar';
+export declare const getWatchedFiles: (watcher: chokidar.FSWatcher) => string[];
 export default class Watcher {
   private dependencyTree;
   private watcher;

package/dist/types/dev-tools/watcher/stats-cache.d.ts

@@ -1,9 +1,10 @@
 export declare class StatsCache {
-  private readonly cachedStats;
+  private readonly cachedHash;
+  private readonly cachedSize;
   add(files: string[]): void;
   refresh(filename: string): void;
   del(filename: string): void;
   isDiff(filename: string): boolean;
   has(filename: string): boolean;
-  private sign;
+  private hash;
 }

package/dist/types/libs/context/context.d.ts

@@ -26,9 +26,11 @@ export declare class ModernServerContext implements ModernServerContextInterface
   params: Record<string, string>;
   logger: Logger;
   metrics?: Metrics;
+  serverData: Record<string, any>;
   constructor(req: IncomingMessage, res: ServerResponse);
   private bind;
   setParams(params: Record<string, string>): void;
+  setServerData(key: string, value: any): void;
   getReqHeader(key: string): string | string[];
   get headers(): import("http").IncomingHttpHeaders;
   get method(): string;

package/dist/types/libs/hook-api/route.d.ts

@@ -3,11 +3,12 @@ import { RouteMatchManager, RouteMatcher } from '../route';
 declare class RouteAPI {
   private readonly router;
   private current;
-  constructor(matched: RouteMatcher, router: RouteMatchManager);
+  private readonly url;
+  constructor(matched: RouteMatcher, router: RouteMatchManager, url: string);
   cur(): import("../route").ModernRoute;
   get(entryName: string): import("../route").ModernRoute | null;
   use(entryName: string): boolean;
 }
 
-export declare const createRouteAPI: (matched: RouteMatcher, router: RouteMatchManager) => RouteAPI;
+export declare const createRouteAPI: (matched: RouteMatcher, router: RouteMatchManager, url: string) => RouteAPI;
 export {};

package/dist/types/libs/render/reader.d.ts

@@ -1,4 +1,17 @@
 /// <reference types="node" />
+export declare class LruReader {
+  private readonly cache;
+  constructor();
+  init(): void;
+  close(): void;
+  read(filepath: string): Promise<{
+    content: Buffer;
+    mtime: Date;
+  } | {
+    content: Buffer;
+  } | null>;
+  update(): void;
+}
 export declare const readFile: (filepath: string) => Promise<Buffer | undefined>;
 export declare const updateFile: () => void;
 export declare const init: () => void;

package/dist/types/libs/render/ssr.d.ts

@@ -3,6 +3,7 @@ import { RenderResult, ServerHookRunner } from '../../type';
 export declare const render: (ctx: ModernServerContext, renderOptions: {
   distDir: string;
   bundle: string;
+  urlPath: string;
   template: string;
   entryName: string;
   staticGenerate: boolean;

package/dist/types/libs/route/matcher.d.ts

@@ -6,7 +6,7 @@ export declare class RouteMatcher {
   urlMatcher?: MatchFunction;
   urlReg?: RegExp;
   constructor(spec: ModernRouteInterface);
-  generate(): ModernRoute;
+  generate(url: string): ModernRoute;
   parseURLParams(pathname: string): Record<string, string>;
   matchLength(pathname: string): number | null;
   matchUrlPath(requestUrl: string): boolean;

package/dist/types/libs/route/route.d.ts

@@ -9,5 +9,6 @@ export declare class ModernRoute implements ModernRouteInterface {
   isSSR: boolean;
   isSPA: boolean;
   enableModernMode?: boolean;
+  params: Record<string, any>;
   constructor(routeSpec: ModernRouteInterface);
 }

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

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

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

@@ -1,4 +1,4 @@
-import { APIServerStartInput } from '@modern-js/server-plugin';
+import { APIServerStartInput } from '@modern-js/server-core';
 import { mergeExtension } from '../utils';
 import { ModernRoute, ModernRouteInterface, RouteMatcher } from '../libs/route';
 import { ApiServerMode } from '../constants';
@@ -8,14 +8,14 @@ export declare class ModernSSRServer extends ModernServer {
   protected warmupSSRBundle(): Promise<void>;
   protected verifyMatch(context: ModernServerContext, matched: RouteMatcher): void;
   protected prepareAPIHandler(_m: ApiServerMode, _: APIServerStartInput['config']): any;
-  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-plugin").Adapter>;
+  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<import("@modern-js/server-core").Adapter>;
   protected preServerInit(): Promise<void>;
 }
 export declare class ModernAPIServer extends ModernServer {
   protected emitRouteHook(_: string, _input: any): Promise<void>;
   protected warmupSSRBundle(): Promise<void>;
   protected prepareWebHandler(_: ReturnType<typeof mergeExtension>): any;
-  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<import("@modern-js/server-plugin").Adapter>;
+  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<import("@modern-js/server-core").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, APIServerStartInput } from '@modern-js/server-plugin';
+import { Adapter, APIServerStartInput } from '@modern-js/server-core';
 import type { NormalizedConfig } from '@modern-js/core';
 import { ModernServerOptions, NextFunction, ServerHookRunner, Metrics, Logger, ReadyOptions } from '../type';
 import { RouteMatchManager, ModernRouteInterface, ModernRoute, RouteMatcher } from '../libs/route';
@@ -68,6 +68,5 @@ export declare class ModernServer {
   private requestHandler;
   private onError;
   private renderErrorPage;
-  private prepareFavicons;
 }
 export {};

package/dist/types/type.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 import type Webpack from 'webpack';
-import { serverManager } from '@modern-js/server-plugin';
+import { serverManager } from '@modern-js/server-core';
 import type { NormalizedConfig } from '@modern-js/core';
 import type { Metrics, Logger, NextFunction } from '@modern-js/types/server';
 import { ModernRouteInterface } from './libs/route';
@@ -12,7 +12,7 @@ declare module 'http' {
 }
 declare module '@modern-js/core' {
   interface UserConfig {
-    bff: {
+    bff?: {
       proxy: Record<string, any>;
     };
   }
@@ -41,9 +41,11 @@ export declare type DevServerOptions = {
 export declare type ModernServerOptions = {
   pwd: string;
   config: NormalizedConfig;
-  plugins?: any[];
+  plugins?: {
+    pluginPath: string;
+  }[];
   dev?: boolean | Partial<DevServerOptions>;
-  compiler?: Webpack.MultiCompiler | Webpack.Compiler;
+  compiler?: Webpack.MultiCompiler | Webpack.Compiler | null;
   routes?: ModernRouteInterface[];
   staticGenerate?: boolean;
   customServer?: boolean;

package/dist/types/utils.d.ts

@@ -1,3 +1,4 @@
+import type { NormalizedConfig } from '@modern-js/core';
 export declare const mergeExtension: (users: any[]) => {
   middleware: any[];
 };
@@ -12,4 +13,7 @@ export declare const createMiddlewareCollecter: () => {
   getMiddlewares: () => CollectMiddlewaresResult;
   addWebMiddleware: (input: any) => void;
   addAPIMiddleware: (input: any) => void;
-};
+};
+export declare const toPath: (reg: string, params: Record<string, any>) => string;
+export declare const getStaticReg: (output?: NormalizedConfig['output']) => RegExp;
+export declare const prepareFavicons: (favicon: string | undefined, faviconByEntries?: Record<string, string | undefined> | undefined) => string[];

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.3.1-beta.0",
+  "version": "1.4.1",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -34,13 +34,13 @@
     "@babel/preset-typescript": "^7.15.0",
     "@babel/register": "^7.15.3",
     "@babel/runtime": "^7",
-    "@modern-js/core": "^1.3.0",
-    "@modern-js/hmr-client": "^1.2.0",
-    "@modern-js/server-plugin": "^1.2.0",
-    "@modern-js/server-utils": "^1.2.0",
-    "@modern-js/bff-utils": "^1.2.0",
-    "@modern-js/utils": "^1.2.0",
-    "axios": "^0.21.4",
+    "@modern-js/core": "^1.4.1",
+    "@modern-js/hmr-client": "^1.2.1",
+    "@modern-js/server-core": "^1.2.2",
+    "@modern-js/server-utils": "^1.2.1",
+    "@modern-js/bff-utils": "^1.2.2",
+    "@modern-js/utils": "^1.3.1",
+    "axios": "^0.24.0",
     "babel-plugin-module-resolver": "^4.1.0",
     "chokidar": "^3.5.2",
     "compare-versions": "^3.6.0",
@@ -60,11 +60,12 @@
     "ua-parser-js": "^0.7.28",
     "webpack-dev-middleware": "^5.0.0",
     "ws": "^8.2.0",
-    "lodash.clone": "^4.5.0"
+    "lodash.clone": "^4.5.0",
+    "cookie": "^0.4.2"
   },
   "devDependencies": {
     "@scripts/build": "0.0.0",
-    "@modern-js/types": "^1.2.0",
+    "@modern-js/types": "^1.3.1",
     "@types/jest": "^26",
     "@types/lru-cache": "^5.1.1",
     "@types/mime-types": "^2.1.0",
@@ -79,6 +80,7 @@
     "@types/webpack-dev-middleware": "^5.0.2",
     "@types/ws": "^7.4.7",
     "@types/lodash.clone": "^4",
+    "@types/cookie": "^0.4.1",
     "typescript": "^4",
     "webpack": "^5.54.0",
     "node-mocks-http": "^1.11.0",
@@ -98,8 +100,7 @@
   },
   "publishConfig": {
     "registry": "https://registry.npmjs.org/",
-    "access": "public",
-    "types": "./dist/types/index.d.ts"
+    "access": "public"
   },
   "scripts": {
     "new": "modern new",

package/tests/context.test.ts

@@ -14,6 +14,7 @@ describe('test server context', () => {
       method: 'GET',
     });
     const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
+    const context = createContext(req, res);
     const {
       method,
       url,
@@ -25,7 +26,7 @@ describe('test server context', () => {
       querystring,
       protocol,
       params,
-    } = createContext(req, res);
+    } = context;
 
     expect(method).toBe('GET');
     expect(url).toBe('/pathname?foo=baz');
@@ -37,5 +38,15 @@ describe('test server context', () => {
     expect(querystring).toBe('foo=baz');
     expect(protocol).toBe('http');
     expect(params).toEqual({});
+
+    expect(context.serverData).toEqual({});
+    context.setServerData('foo', {
+      name: 'foo',
+    });
+    expect(context.serverData).toEqual({
+      foo: {
+        name: 'foo',
+      },
+    });
   });
 });

package/tests/dev.test.ts

@@ -1,11 +1,30 @@
 import http from 'http';
+import path from 'path';
+import { webpack } from 'webpack';
+import { fs, LAUNCH_EDITOR_ENDPOINT } from '@modern-js/utils';
 import SocketServer from '../src/dev-tools/socket-server';
+import DevServerPlugin from '../src/dev-tools/dev-server-plugin';
+import Watcher, { getWatchedFiles } from '../src/dev-tools/watcher';
+import { StatsCache } from '../src/dev-tools/watcher/stats-cache';
+import { createMockHandler } from '../src/dev-tools/mock';
+import getMockData, { getMatched } from '../src/dev-tools/mock/getMockData';
+import { createLaunchEditorHandler } from '../src/dev-tools/launch-editor';
+import { genHttpsOptions } from '../src/dev-tools/https';
+
+const noop = () => {
+  // empty
+};
+
+function getRandomPort() {
+  return Math.floor(Math.random() * (8000 - 1024)) + 1024;
+}
 
 describe('test dev tools', () => {
   test('should socket server work correctly', () => {
+    const port = getRandomPort();
     const socketServer: any = new SocketServer({
       client: {
-        port: '8080',
+        port: port.toString(),
         overlay: false,
         logging: 'error',
         path: '/',
@@ -18,11 +37,9 @@ describe('test dev tools', () => {
       hot: true,
       liveReload: true,
     });
-    const app = http
-      .createServer((req, res) => {
-        res.end();
-      })
-      .listen(8080);
+    const app = http.createServer((req, res) => {
+      res.end();
+    });
 
     socketServer.prepare(app);
     expect(socketServer.app).toBe(app);
@@ -34,6 +51,288 @@ describe('test dev tools', () => {
     socketServer.updateStats(mockStats);
     expect(socketServer.stats).toBe(mockStats);
 
-    app.close();
+    const socket = {
+      state: 1,
+      close() {
+        socket.state = 0;
+        // empty
+      },
+    };
+    socketServer.sockets = [socket];
+    socketServer.close();
+    expect(socket.state).toBe(0);
+  });
+
+  test('should dev server plugin work correctly', () => {
+    const compiler = webpack({});
+    new DevServerPlugin({
+      client: {
+        port: '8080',
+        overlay: false,
+        logging: 'error',
+        path: '/',
+        host: '127.0.0.1',
+      },
+      dev: {
+        writeToDisk: false,
+      },
+      watch: true,
+      hot: true,
+      liveReload: true,
+    }).apply(compiler);
+
+    // expect(compiler.options.entry)
+    const entryPluginHook = compiler.hooks.compilation.taps.filter(
+      tap => tap.name === 'EntryPlugin',
+    );
+    const hotPluginHook = compiler.hooks.compilation.taps.filter(
+      tap => tap.name === 'HotModuleReplacementPlugin',
+    );
+    expect(entryPluginHook.length).toBe(3);
+    expect(hotPluginHook.length).toBe(1);
+  });
+
+  describe('test watcher', () => {
+    let watcher: any;
+    const baseDir = path.join(__dirname, 'fixtures');
+    const watchDir = path.join(baseDir, 'watch/**');
+    const filepath = path.join(baseDir, 'watch', 'index.ts');
+    const filepatha = path.join(baseDir, 'watch', 'a.ts');
+    const txt = path.join(baseDir, 'watch', 'stats.txt');
+
+    afterEach(() => {
+      if (watcher) {
+        watcher.close();
+      }
+      fs.writeFileSync(txt, '1');
+    });
+
+    it('should create watcher instance correctly', resolve => {
+      watcher = new Watcher();
+      expect(watcher.dependencyTree).toBeNull();
+      watcher.createDepTree();
+      expect(watcher.dependencyTree).not.toBeNull();
+
+      expect(watcher.watcher).toBeUndefined();
+      watcher.listen([watchDir], {}, () => {
+        // empty
+      });
+
+      expect(watcher.watcher).toBeDefined();
+      require(filepath);
+      expect(watcher.dependencyTree.getNode(filepath)).toBeUndefined();
+      watcher.updateDepTree();
+      expect(watcher.dependencyTree.getNode(filepath)).toBeDefined();
+      watcher.cleanDepCache(filepath);
+      expect(watcher.dependencyTree.getNode(filepath)).toBeDefined();
+
+      jest.resetModules();
+      watcher.updateDepTree();
+      expect(watcher.dependencyTree.getNode(filepath)).toBeUndefined();
+
+      setTimeout(() => {
+        const fl = getWatchedFiles(watcher.watcher);
+        expect(fl.includes(filepatha)).toBeTruthy();
+        expect(fl.includes(filepath)).toBeTruthy();
+        expect(fl.includes(txt)).toBeTruthy();
+        resolve();
+      }, 1000);
+    });
+
+    it('should stats cache instance work correctly', () => {
+      const statsCache = new StatsCache();
+
+      // should not exist false before add
+      expect(statsCache.has(txt)).toBeFalsy();
+
+      // should exist true after add
+      statsCache.add([txt]);
+      expect(statsCache.has(txt)).toBeTruthy();
+
+      // should diff correctly
+      fs.writeFileSync(txt, 'foo');
+      expect(statsCache.isDiff(txt)).toBeTruthy();
+
+      // should not diff if not refresh
+      fs.writeFileSync(txt, '1');
+      expect(statsCache.isDiff(txt)).toBeFalsy();
+
+      // should diff after refresh
+      fs.writeFileSync(txt, 'foo');
+      statsCache.refresh(txt);
+      fs.writeFileSync(txt, '1');
+      expect(statsCache.isDiff(txt)).toBeTruthy();
+
+      // should diff when content change
+      statsCache.refresh(txt);
+      fs.writeFileSync(txt, '2');
+      expect(statsCache.isDiff(txt)).toBeTruthy();
+
+      // should not exist after del
+      statsCache.del(txt);
+      expect(statsCache.has(txt)).toBeFalsy();
+    });
+  });
+
+  describe('should mock middleware work correctly', () => {
+    const pwd = path.join(__dirname, './fixtures/mock');
+
+    it('should return null if no config mock dir', () => {
+      expect(createMockHandler({ pwd: path.join(pwd, 'empty') })).toBeNull();
+    });
+
+    it('should return null if no api dir', () => {
+      expect(createMockHandler({ pwd: path.join(pwd, 'zero') })).toBeNull();
+    });
+
+    it('should return middleware if mock api exist', async () => {
+      const middleware = createMockHandler({ pwd: path.join(pwd, 'exist') });
+
+      expect(middleware).not.toBeNull();
+
+      let response: any;
+      const context: any = {
+        path: '/api/getInfo',
+        method: 'get',
+        res: {
+          setHeader: noop,
+          end: (data: any) => {
+            response = JSON.parse(data);
+          },
+        },
+      };
+      await middleware?.(context, noop);
+      expect(response).toEqual({
+        data: [1, 2, 3, 4],
+      });
+    });
+
+    it('should get api list correctly', () => {
+      const apiList = getMockData(path.join(pwd, 'exist/config/mock/index.ts'));
+      expect(apiList.length).toBe(3);
+
+      const pathList = apiList.map(api => api.path);
+      expect(pathList).toEqual([
+        '/api/getInfo',
+        '/api/getExample',
+        '/api/addInfo',
+      ]);
+
+      let response: any;
+      const context: any = {
+        res: {
+          setHeader: noop,
+          end: (data: any) => {
+            response = JSON.parse(data);
+          },
+        },
+      };
+
+      apiList[0].handler(context, noop as any);
+      expect(response).toEqual({
+        data: [1, 2, 3, 4],
+      });
+      apiList[1].handler(context, noop as any);
+      expect(response).toEqual({ id: 1 });
+    });
+
+    it('should match api correctly', () => {
+      const apiList = [
+        {
+          method: 'get',
+          path: '/api/getInfo',
+          handler: noop,
+        },
+        {
+          method: 'get',
+          path: '/api/getExample',
+          handler: noop,
+        },
+        {
+          method: 'get',
+          path: '/api/addInfo',
+          handler: noop,
+        },
+      ];
+      const matched = getMatched(
+        { path: '/api/getInfo', method: 'get' } as any,
+        apiList,
+      );
+      expect(matched).toBe(apiList[0]);
+
+      const missMethod = getMatched(
+        { path: '/api/getModern', method: 'post' } as any,
+        apiList,
+      );
+      expect(missMethod).toBeUndefined();
+    });
+  });
+
+  describe('should createLaunchEditorHandler work correctly', () => {
+    const middleware = createLaunchEditorHandler();
+
+    it('should return 200 if filename exist', () => {
+      let response: any;
+      const context: any = {
+        url: LAUNCH_EDITOR_ENDPOINT,
+        query: {
+          filename: 'test.ts',
+        },
+        res: {
+          end: (data: any) => {
+            response = data;
+          },
+        },
+      };
+      middleware(context, noop);
+      expect(context.status).toBe(200);
+      expect(response).toBeUndefined();
+    });
+
+    it('should return 500 if filename not exist', () => {
+      let response: any;
+      const context: any = {
+        url: LAUNCH_EDITOR_ENDPOINT,
+        query: {
+          filename: '',
+        },
+        res: {
+          end: (data: any) => {
+            response = data;
+          },
+        },
+      };
+      middleware(context, noop);
+      expect(context.status).toBe(500);
+      expect(typeof response === 'string').toBeTruthy();
+    });
+
+    it('should invoke next if not launch editor url', () => {
+      let response: any;
+      const context: any = {
+        url: '',
+        res: {
+          end: (data: any) => {
+            response = data;
+          },
+        },
+      };
+      middleware(context, noop);
+      expect(context.status).toBeUndefined();
+      expect(response).toBeUndefined();
+    });
+  });
+
+  test('should get http cert correctly', async () => {
+    // const options = await genHttpsOptions(true);
+    // expect(options.key).toBeDefined();
+    // expect(options.cert).toBeDefined();
+
+    const useOpt = await genHttpsOptions({
+      key: 'foo',
+      cert: 'baz',
+    });
+    expect(useOpt.key).toBe('foo');
+    expect(useOpt.cert).toBe('baz');
   });
 });

package/tests/fixtures/mock/exist/config/mock/index.ts

@@ -0,0 +1,11 @@
+export default {
+  'GET /api/getInfo': { data: [1, 2, 3, 4] },
+
+  '/api/getExample': { id: 1 },
+
+  'GET /api/addInfo': (req: any, res: any) => {
+    setTimeout(() => {
+      res.end('delay 2000ms');
+    }, 2000);
+  },
+};

package/tests/fixtures/mock/zero/config/mock/index.ts

@@ -0,0 +1 @@
+export default {};