@modern-js/server 1.3.0 → 1.4.0

package/tests/ssr.test.ts

@@ -0,0 +1,34 @@
+import path from 'path';
+import { render } from '../src/libs/render/ssr';
+
+describe('test ssr render function', () => {
+  test('should return content correctly ', async () => {
+    const renderResult = await render(
+      {
+        params: {},
+        pathname: '/foo',
+        host: 'localhost:8080',
+        query: {},
+        url: 'localhost:8080/foo',
+        cookieMap: {},
+        headers: {},
+      } as any,
+      {
+        urlPath: '/foo',
+        bundle: 'bundle.js',
+        distDir: path.join(__dirname, 'fixtures', 'ssr'),
+        template: 'tpl.html',
+        entryName: 'foo',
+        staticGenerate: false,
+      } as any,
+      {
+        extendSSRContext: () => {
+          // empty
+        },
+      } as any,
+    );
+
+    expect(renderResult.content).toMatch('Modern.js');
+    expect(renderResult.contentType).toMatch('text/html; charset=utf-8');
+  });
+});

package/tests/utils.test.ts

@@ -1,3 +1,4 @@
+import { compile } from 'path-to-regexp';
 import {
   noop,
   mergeExtension,
@@ -68,4 +69,9 @@ describe('test server utils', () => {
       expect(after.api).toEqual([middleware]);
     });
   });
+
+  test('should return full path', () => {
+    const fn = compile('/home/:id', { encode: encodeURIComponent });
+    expect(fn({ id: 2 })).toBe('/home/2');
+  });
 });

package/tests/watcher.test.ts

@@ -0,0 +1,98 @@
+import * as path from 'path';
+import { fs } from '@modern-js/utils';
+import Watcher from '../src/dev-tools/watcher';
+
+jest.useRealTimers();
+
+describe('watcher', () => {
+  let watcher: Watcher;
+  jest.setTimeout(25000);
+  beforeAll(() => {
+    watcher = new Watcher();
+  });
+
+  test('should emit change', done => {
+    const pwd = path.join(__dirname, './fixtures/pure');
+    const serverDir = path.normalize(path.join(pwd, './tmp-server'));
+
+    const callback = jest.fn();
+    if (fs.pathExistsSync(serverDir)) {
+      fs.removeSync(serverDir);
+    }
+    const writeFiles = () => {
+      fs.writeFileSync(
+        path.normalize(path.join(serverDir, 'index.js')),
+        'test',
+        'utf8',
+      );
+    };
+
+    const clear = () => {
+      fs.removeSync(serverDir);
+    };
+
+    fs.mkdirSync(serverDir);
+
+    watcher.listen(
+      [`${serverDir}/**/*`],
+      {
+        ignoreInitial: true,
+        ignored: /api\/typings\/.*/,
+      },
+      async () => {
+        callback();
+        expect(callback).toHaveBeenCalledTimes(1);
+        await watcher.close();
+        clear();
+        done();
+      },
+    );
+
+    setTimeout(writeFiles, 100);
+  });
+
+  test('should not emit change when typings file changed', done => {
+    const pwd = path.join(__dirname, './fixtures/pure');
+    const apiDir = path.normalize(path.join(pwd, './api'));
+
+    const callback = jest.fn();
+
+    if (fs.pathExistsSync(apiDir)) {
+      fs.removeSync(apiDir);
+    }
+
+    const writeFiles = () => {
+      fs.writeFileSync(
+        path.normalize(path.join(apiDir, 'typings/index.js')),
+        'test',
+        'utf8',
+      );
+    };
+
+    const clear = () => {
+      fs.removeSync(apiDir);
+    };
+
+    fs.mkdirSync(path.normalize(path.join(apiDir, 'typings')), {
+      recursive: true,
+    });
+
+    watcher.listen(
+      [`${apiDir}/**/*`],
+      {
+        ignoreInitial: true,
+        ignored: /api\/typings\/.*/,
+      },
+      callback,
+    );
+
+    setTimeout(async () => {
+      expect(callback).toHaveBeenCalledTimes(0);
+      await watcher.close();
+      clear();
+      done();
+    }, 1000);
+
+    setTimeout(writeFiles);
+  });
+});

package/src/constants.ts

@@ -1,26 +0,0 @@
-export const AGGRED_DIR = {
-  mock: 'config/mock',
-  server: 'server',
-  api: 'api',
-  shared: 'shared',
-  lambda: 'lambda',
-};
-
-export enum ApiServerMode {
-  func = 'function',
-  frame = 'framework',
-}
-
-export const ERROR_DIGEST = {
-  INIT: 'Server init error',
-  ENOTF: 'Page could not be found',
-  WARMUP: 'SSR warmup failed',
-  EINTER: 'Internal server error',
-  ERENDER: 'SSR render failed',
-  EMICROINJ: 'Get micro-frontend info failed',
-};
-
-export const ERROR_PAGE_TEXT: Record<number, string> = {
-  404: 'This page could not be found.',
-  500: 'Internal Server Error.',
-};

package/src/dev-tools/babel/register.ts

@@ -1,37 +0,0 @@
-import path from 'path';
-import { resolveBabelConfig } from '@modern-js/server-utils';
-import { ModernServerOptions } from '../../type';
-
-const registerDirs = ['./api', './server', './config/mock', './shared'];
-
-export const enableRegister = (
-  projectRoot: string,
-  config: ModernServerOptions['config'],
-) => {
-  const TS_CONFIG_FILENAME = `tsconfig.json`;
-  const tsconfigPath = path.resolve(projectRoot, TS_CONFIG_FILENAME);
-
-  const babelConfig = resolveBabelConfig(projectRoot, config, {
-    tsconfigPath,
-    syntax: 'es6+',
-    type: 'commonjs',
-  });
-
-  return require('@babel/register')({
-    ...babelConfig,
-    only: [
-      function (filePath: string) {
-        // TODO: wait params
-        if (filePath.includes(`node_modules${path.sep}.modern-js`)) {
-          return true;
-        }
-        return registerDirs.some(registerDir =>
-          filePath.startsWith(path.join(projectRoot, registerDir)),
-        );
-      },
-    ],
-    extensions: ['.js', '.ts'],
-    babelrc: false,
-    root: projectRoot,
-  });
-};

package/src/dev-tools/dev-server-plugin.ts

@@ -1,48 +0,0 @@
-import Webpack from 'webpack';
-import { DevServerOptions } from '../type';
-
-const { EntryPlugin } = Webpack;
-export default class DevServerPlugin {
-  private readonly options: DevServerOptions;
-
-  constructor(options: DevServerOptions) {
-    this.options = options;
-  }
-
-  apply(compiler: Webpack.Compiler) {
-    const { options } = this;
-
-    const host = `&host=${options.client.host || 'localhost'}`;
-    const path = `&path=${options.client.path}`;
-    const port = `&port=${options.client.port}`;
-
-    // Todo @songzhenwei
-    const clientEntry = `${require.resolve(
-      '@modern-js/hmr-client',
-    )}?${host}${path}${port}`;
-    const hotEntry = require.resolve('webpack/hot/dev-server');
-    const additionalEntries = [clientEntry, hotEntry];
-
-    // use a hook to add entries if available
-    for (const additionalEntry of additionalEntries) {
-      new EntryPlugin(compiler.context, additionalEntry, {
-        name: undefined,
-      }).apply(compiler);
-    }
-
-    // Todo remove, client must inject.
-    const compilerOptions = compiler.options;
-    compilerOptions.plugins = compilerOptions.plugins || [];
-    if (
-      hotEntry &&
-      !compilerOptions.plugins.find(
-        p => p.constructor === Webpack.HotModuleReplacementPlugin,
-      )
-    ) {
-      // apply the HMR plugin, if it didn't exist before.
-      const plugin = new Webpack.HotModuleReplacementPlugin();
-
-      plugin.apply(compiler);
-    }
-  }
-}

package/src/dev-tools/https/global.d.ts

@@ -1,3 +0,0 @@
-declare module 'selfsigned' {
-  function generate(attributes: any, opt: any): { private: any; cert: any };
-}

package/src/dev-tools/https/index.ts

@@ -1,12 +0,0 @@
-import * as devcert from 'devcert';
-
-export const genHttpsOptions = async (userOptions: any) => {
-  const httpsOptions = userOptions === true ? {} : userOptions;
-
-  if (!httpsOptions.key || !httpsOptions.cert) {
-    const selfsign = await devcert.certificateFor(['localhost']);
-    return selfsign;
-  }
-
-  return httpsOptions;
-};

package/src/dev-tools/launch-editor/index.ts

@@ -1,29 +0,0 @@
-import { LAUNCH_EDITOR_ENDPOINT, logger } from '@modern-js/utils';
-import { ModernServerContext } from '../../libs/context';
-import { NextFunction } from '../../type';
-
-export const createLaunchEditorHandler =
-  // eslint-disable-next-line consistent-return
-  () => (ctx: ModernServerContext, next: NextFunction) => {
-    if (ctx.url.startsWith(LAUNCH_EDITOR_ENDPOINT)) {
-      const { filename, line = 1, column = 1 } = ctx.query;
-      if (!filename) {
-        ctx.status = 500;
-        ctx.res.end(
-          `launch-editor-middleware: required query param "filename" is missing.`,
-        );
-      } else {
-        require('launch-editor')(
-          `${filename as string}:${line as string}:${column as string}`,
-          'code',
-          (file: string, errorMessage: string) => {
-            logger.error(`Launch ${file} in editor failed.\n${errorMessage}`);
-          },
-        );
-        ctx.status = 200;
-        ctx.res.end();
-      }
-    } else {
-      return next();
-    }
-  };

package/src/dev-tools/mock/getMockData.ts

@@ -1,109 +0,0 @@
-import { IncomingMessage, ServerResponse } from 'http';
-import { compatRequire } from '@modern-js/utils';
-import { NextFunction } from '../../type';
-import { ModernServerContext } from '../../libs/context';
-
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const VALID_METHODS = ['get', 'post', 'put', 'delete', 'patch'];
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-const BODY_PARSED_METHODS = ['post', 'put', 'delete', 'patch'];
-
-export type MockConfig = Record<
-  string,
-  | {
-      data: any;
-    }
-  | ((
-      req: IncomingMessage,
-      res: ServerResponse,
-      next: NextFunction,
-    ) => Promise<void>)
->;
-
-export type MockApi = {
-  method: string;
-  path: string;
-  handler: ReturnType<
-    typeof createFunctionDataHandler | typeof createStaticDataHandler
-  >;
-};
-
-const createFunctionDataHandler =
-  (
-    method: string,
-    handler: (
-      req: IncomingMessage,
-      res: ServerResponse,
-      next: NextFunction,
-    ) => void,
-  ) =>
-  async (context: ModernServerContext, next: NextFunction) => {
-    const { req, res } = context;
-    return handler(req, res, next);
-  };
-
-const createStaticDataHandler =
-  (method: string, handler: Record<string, any>) =>
-  (context: ModernServerContext) => {
-    const { res } = context;
-    res.setHeader('Content-Type', 'application/json');
-    res.end(JSON.stringify(handler));
-  };
-
-const allowTypes = ['object', 'function'];
-const normalizeConfig = (mockConfig: MockConfig) =>
-  Object.keys(mockConfig).reduce((acc, key) => {
-    const handler = mockConfig[key];
-    const type = typeof handler;
-
-    if (!allowTypes.includes(type)) {
-      throw new Error(
-        `mock value of ${key} should be object or function, but got ${type}`,
-      );
-    }
-
-    const meta = parseKey(key);
-    if (type === 'object') {
-      acc.push({
-        ...meta,
-        handler: createStaticDataHandler(meta.method, handler),
-      });
-    } else {
-      acc.push({
-        ...meta,
-        handler: createFunctionDataHandler(meta.method, handler as any),
-      });
-    }
-
-    return acc;
-  }, [] as MockApi[]);
-
-const _blank = ' ';
-const parseKey = (key: string) => {
-  // 'Method /pathname' | '/pathname'
-  const splited = key.split(_blank).filter(Boolean);
-  if (splited.length > 1) {
-    const [method, pathname] = splited;
-    return {
-      method: method.toLowerCase(),
-      path: pathname,
-    };
-  }
-
-  // default return get method
-  return {
-    method: 'get',
-    path: key,
-  };
-};
-
-export default (filepath: string) => {
-  const mockModule = compatRequire(filepath);
-
-  if (!mockModule) {
-    throw new Error(`Mock file ${filepath} parsed failed!`);
-  }
-
-  const data = normalizeConfig(mockModule);
-  return data;
-};

package/src/dev-tools/mock/index.ts

@@ -1,63 +0,0 @@
-import path from 'path';
-import { fs } from '@modern-js/utils';
-import { match } from 'path-to-regexp';
-import { NextFunction } from '../../type';
-import { ModernServerContext } from '../../libs/context';
-import { AGGRED_DIR } from '../../constants';
-import getMockData, { MockApi } from './getMockData';
-
-const getMatched = (context: ModernServerContext, mockApiList: MockApi[]) => {
-  const { path: targetPathname, method: targetMethod } = context;
-
-  const matched = mockApiList.find(mockApi => {
-    const { method, path: pathname } = mockApi;
-    if (method.toLowerCase() === targetMethod.toLowerCase()) {
-      return match(pathname, {
-        encode: encodeURI,
-        decode: decodeURIComponent,
-      })(targetPathname);
-    }
-
-    return false;
-  });
-
-  return matched;
-};
-
-export const createMockHandler = ({ pwd }: { pwd: string }) => {
-  const exts = ['.ts', '.js'];
-  let filepath = '';
-
-  for (const ext of exts) {
-    const maybeMatch = path.join(pwd, `${AGGRED_DIR.mock}/index${ext}`);
-    if (fs.existsSync(maybeMatch)) {
-      filepath = maybeMatch;
-      break;
-    }
-  }
-
-  if (!filepath) {
-    return null;
-  }
-
-  const apiList = getMockData(filepath);
-  if (!apiList || apiList.length === 0) {
-    return null;
-  }
-
-  return async (context: ModernServerContext, next: NextFunction) => {
-    const { res } = context;
-    const matched = getMatched(context, apiList);
-
-    if (!matched) {
-      return next();
-    }
-
-    if (matched) {
-      res.setHeader('Access-Control-Allow-Origin', '*');
-      return matched.handler(context, next);
-    } else {
-      return next();
-    }
-  };
-};

package/src/dev-tools/socket-server.ts

@@ -1,192 +0,0 @@
-import { Server } from 'http';
-import { Socket } from 'net';
-import ws from 'ws';
-import type { Stats } from 'webpack';
-import { logger } from '@modern-js/utils';
-import { DevServerOptions } from '../type';
-import { noop } from '../utils';
-
-interface ExtWebSocket extends ws {
-  isAlive: boolean;
-}
-
-export default class SocketServer {
-  private wsServer!: ws.Server;
-
-  private readonly sockets: ws[] = [];
-
-  private readonly options: DevServerOptions;
-
-  private app?: Server;
-
-  private stats?: Stats;
-
-  constructor(options: DevServerOptions) {
-    this.options = options;
-  }
-
-  // create socket, install socket handler, bind socket event
-  public prepare(app: Server) {
-    this.app = app;
-
-    this.wsServer = new ws.Server({
-      noServer: true,
-      path: this.options.client.path,
-    });
-
-    // listen upgrade event to handle socket
-    this.app.on('upgrade', (req, sock, head) => {
-      if (!this.wsServer.shouldHandle(req)) {
-        return;
-      }
-
-      this.wsServer.handleUpgrade(req, sock as Socket, head, connection => {
-        this.wsServer.emit('connection', connection, req);
-      });
-    });
-
-    this.wsServer.on('error', (err: Error) => {
-      // only dev server, use default logger
-      logger.error(err);
-    });
-
-    setInterval(() => {
-      this.wsServer.clients.forEach(socket => {
-        const extWs = socket as ExtWebSocket;
-        if (!extWs.isAlive) {
-          extWs.terminate();
-        } else {
-          extWs.isAlive = false;
-          extWs.ping(noop);
-        }
-      });
-    }, 30000);
-
-    this.wsServer.on('connection', socket => {
-      const connection = socket as ExtWebSocket;
-
-      connection.isAlive = true;
-      connection.on('pong', () => {
-        connection.isAlive = true;
-      });
-
-      if (!connection) {
-        return;
-      }
-
-      this.sockets.push(connection);
-
-      connection.on('close', () => {
-        const idx = this.sockets.indexOf(connection);
-
-        if (idx >= 0) {
-          this.sockets.splice(idx, 1);
-        }
-      });
-
-      if (this.options.client.logging) {
-        this.sockWrite('logging', this.options.client.logging);
-      }
-
-      if (this.options.hot || this.options.hot === 'only') {
-        this.sockWrite('hot');
-      }
-
-      if (this.options.liveReload) {
-        this.sockWrite('liveReload');
-      }
-
-      if (this.options.client.progress) {
-        this.sockWrite('progress', this.options.client.progress);
-      }
-
-      if (this.options.client.overlay) {
-        this.sockWrite('overlay', this.options.client.overlay);
-      }
-
-      // send first stats to active client sock if stats exist
-      if (this.stats) {
-        this.sendStats(true);
-      }
-    });
-  }
-
-  public updateStats(stats: Stats) {
-    this.stats = stats;
-    this.sendStats();
-  }
-
-  // write message to each socket
-  public sockWrite(
-    type: string,
-    data?: Record<string, any> | string | boolean,
-  ) {
-    this.sockets.forEach(socket => {
-      this.send(socket, JSON.stringify({ type, data }));
-    });
-  }
-
-  public close(connection: ws) {
-    connection.close();
-  }
-
-  // get standard stats
-  private getStats() {
-    const curStats = this.stats;
-
-    if (!curStats) {
-      return null;
-    }
-
-    const defaultStats: Record<string, boolean> = {
-      all: false,
-      hash: true,
-      assets: true,
-      warnings: true,
-      errors: true,
-      errorDetails: false,
-    };
-
-    return curStats.toJson(defaultStats);
-  }
-
-  // determine what message should send by stats
-  private sendStats(force = false) {
-    const stats = this.getStats();
-
-    // this should never happend
-    if (!stats) {
-      return null;
-    }
-
-    const shouldEmit =
-      !force &&
-      stats &&
-      (!stats.errors || stats.errors.length === 0) &&
-      stats.assets &&
-      stats.assets.every((asset: any) => !asset.emitted);
-
-    if (shouldEmit) {
-      return this.sockWrite('still-ok');
-    }
-
-    this.sockWrite('hash', stats.hash);
-
-    if (stats.errors && stats.errors.length > 0) {
-      return this.sockWrite('errors', stats.errors);
-    } else if (stats.warnings && stats.warnings.length > 0) {
-      return this.sockWrite('warnings', stats.warnings);
-    } else {
-      return this.sockWrite('ok');
-    }
-  }
-
-  // send message to connecting socket
-  private send(connection: ws, message: string) {
-    if (connection.readyState !== 1) {
-      return;
-    }
-
-    connection.send(message);
-  }
-}