@modern-js/server 1.3.0 → 1.4.0

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';

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

@@ -12,4 +12,5 @@ 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;

package/jest.config.js

@@ -4,5 +4,6 @@ const sharedConfig = require('@scripts/jest-config');
 module.exports = {
   // eslint-disable-next-line node/no-unsupported-features/es-syntax
   ...sharedConfig,
+  testEnvironment: 'node',
   rootDir: __dirname,
 };

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.3.0",
+  "version": "1.4.0",
   "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.0",
+    "@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.0",
+    "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.0",
     "@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",

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 {};

package/tests/fixtures/pure/tsconfig.json

@@ -5,7 +5,6 @@
     "jsx": "preserve",
     "baseUrl": "./",
     "paths": {
-      ,
       "@shared/*": ["./shared/*"]
     }
   },

package/tests/fixtures/route-spec/dynamic.json

@@ -0,0 +1,13 @@
+{
+  "routes": [
+    {
+      "urlPath": "/entry/:id",
+      "entryName": "entry",
+      "entryPath": "html/entry/index.html",
+      "isSPA": true,
+      "isSSR": true,
+      "enableModernMode": false,
+      "bundle": "bundles/entry.js"
+    }
+  ]
+}

package/tests/fixtures/ssr/bundle.js

@@ -0,0 +1,5 @@
+const { SERVER_RENDER_FUNCTION_NAME } = require('@modern-js/utils');
+
+module.exports = {
+  [SERVER_RENDER_FUNCTION_NAME]: () => '<div>Modern.js</div>',
+};

package/tests/fixtures/watch/a.ts

@@ -0,0 +1,3 @@
+export default {
+  name: 'a',
+};

package/tests/fixtures/watch/index.ts

@@ -0,0 +1,5 @@
+import a from './a';
+
+export default {
+  a,
+};

package/tests/fixtures/watch/stats.txt

@@ -0,0 +1 @@
+1

package/tests/hook.test.ts

@@ -10,7 +10,7 @@ describe('test hook api', () => {
     manager.reset(spec.routes);
     const matcher = manager.match('/home');
 
-    const routeAPI = createRouteAPI(matcher!, manager);
+    const routeAPI = createRouteAPI(matcher!, manager, '');
     expect(routeAPI.cur().entryName).toBe('home');
     expect(routeAPI.get('entry')?.entryPath).toBe('html/entry/index.html');
 

package/tests/route.test.ts

@@ -1,5 +1,6 @@
 import { RouteMatchManager, RouteMatcher } from '../src/libs/route';
 import spec from './fixtures/route-spec/index.json';
+import dynamic from './fixtures/route-spec/dynamic.json';
 
 describe('test route', () => {
   describe('test route matcher', () => {
@@ -12,7 +13,7 @@ describe('test route', () => {
       expect(matcher.urlMatcher).toBeUndefined();
 
       const { isSSR, isApi, isSPA, urlPath, entryName, entryPath } =
-        matcher.generate();
+        matcher.generate('');
 
       expect(isSSR).toBeTruthy();
       expect(isApi).toBeFalsy();
@@ -38,11 +39,11 @@ describe('test route', () => {
 
       const matchedByEntry = manager.matchEntry('home');
       expect(matchedByEntry).toBeDefined();
-      expect(matchedByEntry?.generate().entryName).toBe('home');
+      expect(matchedByEntry?.generate('').entryName).toBe('home');
 
       const matchedByUrl = manager.match('/entry');
       expect(matchedByUrl).toBeDefined();
-      expect(matchedByUrl?.generate().entryName).toBe('entry');
+      expect(matchedByUrl?.generate('').entryName).toBe('entry');
 
       const SSRUrlBundles = manager.getBundles();
       expect(SSRUrlBundles).toEqual(['bundles/entry.js', 'bundles/home.js']);
@@ -50,5 +51,27 @@ describe('test route', () => {
       manager.reset([]);
       expect(manager.matchers.length).toBe(0);
     });
+
+    test('should manager work correctly with dynamic spec', async () => {
+      const manager = new RouteMatchManager();
+      expect(manager.matchers.length).toBe(0);
+      manager.reset(dynamic.routes);
+      expect(manager.matchers.length).toBe(1);
+
+      const matched = manager.match('/entry/001');
+      expect(matched).toBeDefined();
+      const route = matched?.generate('/entry/001');
+      expect(route?.entryName).toBe('entry');
+      expect(route?.params).toEqual({ id: '001' });
+
+      const matchedWithTrail = manager.match('/entry/001/a');
+      expect(matchedWithTrail).toBeDefined();
+      const routeWithTrail = matchedWithTrail?.generate('/entry/001/a');
+      expect(routeWithTrail?.entryName).toBe('entry');
+      expect(routeWithTrail?.params).toEqual({ id: '001' });
+
+      const miss = manager.match('/entry');
+      expect(miss).toBeUndefined();
+    });
   });
 });

package/tests/server.test.ts

@@ -3,6 +3,7 @@ import { defaultsConfig, NormalizedConfig } from '@modern-js/core';
 import { ModernServerContext, NextFunction } from '@modern-js/types';
 import createServer, { Server } from '../src';
 import { ModernServer } from '../src/server/modern-server';
+import Watcher from '../src/dev-tools/watcher';
 
 describe('test server', () => {
   test('should throw error when ', resolve => {
@@ -99,3 +100,21 @@ describe('test server', () => {
     });
   });
 });
+
+describe('dev server', () => {
+  const pwd = path.join(__dirname, './fixtures/pure');
+  let devServer: Server;
+
+  test('watch', async () => {
+    devServer = await createServer({
+      config: defaultsConfig as NormalizedConfig,
+      pwd,
+      dev: true,
+    });
+
+    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+    // @ts-expect-error
+    expect(devServer.server.watcher).toBeInstanceOf(Watcher);
+    await devServer.close();
+  });
+});