@modern-js/server 1.4.3 → 1.4.4

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

@@ -1,5 +1,4 @@
-import { NextFunction } from '../../type';
-import { ModernServerContext } from '../../libs/context';
+import { ModernServerContext, NextFunction } from '@modern-js/types';
 export declare const createMockHandler: ({
   pwd
 }: {

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

@@ -2,7 +2,7 @@
 import { Server } from 'http';
 import ws from 'ws';
 import type { Stats } from 'webpack';
-import { DevServerOptions } from '../type';
+import { DevServerOptions } from '../types';
 export default class SocketServer {
   private wsServer;
   private readonly sockets;

package/dist/types/index.d.ts

@@ -1,9 +1,8 @@
-import { ModernServerOptions } from './type';
-import { Server } from './server';
-export type { SSRServerContext } from './libs/render/type';
+import { DevServer as Server } from './server';
+import { ModernDevServerOptions } from './types';
 export { Server };
-export type { ModernServerOptions };
+export type { ModernDevServerOptions };
 
-declare const _default: (options: ModernServerOptions) => Promise<Server>;
+declare const _default: (options: ModernDevServerOptions) => Promise<Server>;
 
 export default _default;

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

@@ -1,11 +1,12 @@
 import type { APIServerStartInput } from '@modern-js/server-core';
-import { mergeExtension } from '../../utils';
-import { ModernRouteInterface } from '../../libs/route';
-import { ApiServerMode } from '../../constants';
+import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
+import { ApiServerMode } from '@modern-js/prod-server';
 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-core").Adapter>;
+  protected prepareWebHandler(extension: {
+    middleware: any[];
+  }): Promise<import("@modern-js/server-core").Adapter>;
   protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
 }
 export declare class ModernAPIDevServer extends ModernDevServer {

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

@@ -1,7 +1,7 @@
 /// <reference types="node" />
 import http, { Server, IncomingMessage, ServerResponse } from 'http';
-import { ModernServer } from '../modern-server';
-import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '../../type';
+import { ServerHookRunner, ReadyOptions, ModernServer } from '@modern-js/prod-server';
+import { ModernDevServerOptions } from '../types';
 export declare class ModernDevServer extends ModernServer {
   private devProxyHandler;
   private mockHandler;
@@ -10,12 +10,13 @@ export declare class ModernDevServer extends ModernServer {
   private socketServer;
   private watcher;
   private devMiddleware;
-  constructor(options: ModernServerOptions);
+  constructor(options: ModernDevServerOptions);
   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>;
+  protected warmupSSRBundle(): void;
   private setupCompiler;
   private setupDevServerPlugin;
   private setupHooks;

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

@@ -1,20 +1,5 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse, Server as httpServer } from 'http';
-import { ModernServerOptions, ReadyOptions } from '../type';
-export declare class Server {
-  options: ModernServerOptions;
-  private server;
-  private app;
-  private runner;
-  constructor(options: ModernServerOptions);
-  getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: (() => void) | undefined) => void;
-  ready(readyOptions?: ReadyOptions): void;
-  init(): Promise<this>;
-  listen(port: number | undefined, listener: any): void;
-  listener(app: httpServer): void;
-  close(): Promise<void>;
-  private createProdServer;
-  private createDevServer;
-  private createHookRunner;
-  private initAppContext;
+import { Server } from '@modern-js/prod-server';
+import { ModernDevServerOptions } from '../types';
+export declare class DevServer extends Server {
+  constructor(options: ModernDevServerOptions);
 }

package/dist/types/types.d.ts

@@ -0,0 +1,28 @@
+import { ModernServerOptions } from '@modern-js/prod-server';
+import type Webpack from 'webpack';
+export declare type DevServerOptions = {
+  client: {
+    port: string;
+    overlay: boolean;
+    logging: string;
+    path: string;
+    host: string;
+    progress?: boolean;
+  };
+  dev: {
+    writeToDisk: boolean | ((filename: string) => boolean);
+  };
+  watch: boolean;
+  hot: boolean | string;
+  liveReload: boolean;
+  https?: boolean | {
+    key: string;
+    cert: string;
+  };
+  [propName: string]: any;
+};
+export declare type ExtraOptions = {
+  dev?: boolean | Partial<DevServerOptions>;
+  compiler?: Webpack.MultiCompiler | Webpack.Compiler | null;
+};
+export declare type ModernDevServerOptions = ModernServerOptions & ExtraOptions;

package/modern.config.js

@@ -1,2 +1,6 @@
 /** @type {import('@modern-js/module-tools').UserConfig} */
-module.exports = {};
+module.exports = {
+  output: {
+    disableSourceMap: true,
+  },
+};

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "1.4.3",
+  "version": "1.4.4",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/js/node/index.js",
@@ -28,70 +28,38 @@
     }
   },
   "dependencies": {
-    "@babel/core": "7.16.7",
-    "@babel/compat-data": "^7.15.0",
-    "@babel/preset-env": "^7.15.0",
-    "@babel/preset-typescript": "^7.15.0",
+    "@modern-js/prod-server": "^1.0.1",
     "@babel/register": "^7.15.3",
-    "@babel/runtime": "^7",
     "@modern-js/hmr-client": "^1.2.2",
-    "@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.2",
-    "axios": "^0.24.0",
-    "babel-plugin-module-resolver": "^4.1.0",
+    "@modern-js/utils": "^1.3.3",
     "chokidar": "^3.5.2",
-    "compare-versions": "^3.6.0",
     "devcert": "^1.1.3",
-    "fs-extra": "^10.0.0",
-    "http-proxy-middleware": "^2.0.1",
-    "ignore-styles": "^5.0.1",
     "launch-editor": "^2.2.1",
-    "lru-cache": "^6.0.0",
-    "mime-types": "^2.1.32",
     "minimatch": "^3.0.4",
-    "parseurl": "^1.3.3",
     "path-to-regexp": "^6.2.0",
-    "serialize-javascript": "^6.0.0",
-    "serve-static": "^1.14.1",
     "tsconfig-paths": "^3.11.0",
-    "ua-parser-js": "^0.7.28",
     "webpack-dev-middleware": "^5.0.0",
-    "ws": "^8.2.0",
-    "lodash.clone": "^4.5.0",
-    "cookie": "^0.4.2"
+    "ws": "^8.2.0"
   },
   "devDependencies": {
-    "@modern-js/core": "^1.4.3",
+    "@modern-js/server-core": "^1.2.2",
+    "@modern-js/core": "^1.4.4",
     "@scripts/build": "0.0.0",
-    "@modern-js/types": "^1.3.3",
+    "@modern-js/types": "^1.3.4",
     "@types/jest": "^26",
-    "@types/lru-cache": "^5.1.1",
-    "@types/mime-types": "^2.1.0",
     "@types/minimatch": "^3.0.5",
     "@types/node": "^14",
-    "@types/parseurl": "^1.3.1",
-    "@types/react": "^17",
-    "@types/react-dom": "^17",
-    "@types/serialize-javascript": "^5.0.1",
-    "@types/serve-static": "^1.13.10",
-    "@types/ua-parser-js": "^0.7.36",
     "@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",
-    "portfinder": "^1.0.28",
     "jest": "^27",
     "@scripts/jest-config": "0.0.0",
     "websocket": "^1"
   },
   "peerDependencies": {
-    "webpack": "^5.54.0",
-    "@modern-js/core": "^1.4.3"
+    "webpack": "^5.54.0"
   },
   "sideEffects": false,
   "modernConfig": {

package/tests/server.test.ts

@@ -2,7 +2,6 @@ import path from 'path';
 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', () => {
@@ -21,8 +20,10 @@ describe('test server', () => {
     const server = await createServer({
       config: defaultsConfig as NormalizedConfig,
       pwd: path.join(__dirname, './fixtures/pure'),
+      dev: true,
     });
     expect(server instanceof Server).toBe(true);
+    await server.close();
   });
 
   describe('shoule get production modern server instance', () => {
@@ -32,6 +33,7 @@ describe('test server', () => {
       const server = await createServer({
         config: defaultsConfig as NormalizedConfig,
         pwd: appDirectory,
+        dev: true,
       });
       const modernServer = (server as any).server;
 
@@ -47,18 +49,20 @@ describe('test server', () => {
       } = modernServer;
       expect(pwd).toBe(appDirectory);
       expect(distDir).toBe(path.join(appDirectory, 'dist'));
-      expect(workDir).toBe(distDir);
+      expect(workDir).toBe(appDirectory);
       expect(conf).toBe(defaultsConfig);
       expect(handlers).toBeDefined();
       expect(isDev).toBeFalsy();
       expect(staticGenerate).toBeFalsy();
       expect(presetRoutes).toBeUndefined();
+      await server.close();
     });
 
     test('should add handler correctly', async () => {
       const server = await createServer({
         config: defaultsConfig as NormalizedConfig,
         pwd: appDirectory,
+        dev: true,
       });
       const modernServer = (server as any).server;
 
@@ -86,17 +90,20 @@ describe('test server', () => {
 
       expect(newLen + 1).toBe(nextLen);
       expect(modernServer.handlers[nextLen - 1]).toBe(asyncHandler);
+      await server.close();
     });
 
     test('should get request handler correctly', async () => {
       const server = await createServer({
         config: defaultsConfig as NormalizedConfig,
         pwd: appDirectory,
+        dev: true,
       });
 
-      const modernServer: ModernServer = (server as any).server;
+      const modernServer: any = (server as any).server;
       const handler = modernServer.getRequestHandler();
       expect(typeof handler === 'function').toBeTruthy();
+      await server.close();
     });
   });
 });

package/dist/js/modern/constants.js

@@ -1,26 +0,0 @@
-export const AGGRED_DIR = {
-  mock: 'config/mock',
-  server: 'server',
-  api: 'api',
-  shared: 'shared',
-  lambda: 'lambda'
-};
-export let ApiServerMode;
-
-(function (ApiServerMode) {
-  ApiServerMode["func"] = "function";
-  ApiServerMode["frame"] = "framework";
-})(ApiServerMode || (ApiServerMode = {}));
-
-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 = {
-  404: 'This page could not be found.',
-  500: 'Internal Server Error.'
-};

package/dist/js/modern/libs/context/context.js

@@ -1,180 +0,0 @@
-import { URL } from 'url';
-import qs from 'querystring';
-import { toMessage } from "../../utils";
-export class ModernServerContext {
-  /**
-   * http request
-   */
-
-  /**
-   * http response
-   */
-
-  /**
-   * url params
-   */
-  constructor(req, res) {
-    this.req = void 0;
-    this.res = void 0;
-    this.params = {};
-    this.logger = void 0;
-    this.metrics = void 0;
-    this.serverData = void 0;
-    this.req = req;
-    this.res = res;
-    this.logger = req.logger;
-    this.metrics = req.metrics;
-    this.serverData = {};
-    this.bind();
-  }
-
-  bind() {
-    const {
-      req,
-      res
-    } = this;
-
-    req.get = key => this.getReqHeader(key);
-
-    res.set = (key, value) => this.res.setHeader(key, value);
-  }
-
-  setParams(params) {
-    this.params = params;
-  }
-
-  setServerData(key, value) {
-    this.serverData[key] = value;
-  }
-
-  getReqHeader(key) {
-    const {
-      req
-    } = this;
-    const field = key.toLowerCase();
-
-    switch (field) {
-      case 'referer':
-      case 'referrer':
-        return req.headers.referrer || req.headers.referer || '';
-
-      default:
-        return req.headers[field] || '';
-    }
-  }
-  /* request property */
-
-
-  get headers() {
-    return this.req.headers;
-  }
-
-  get method() {
-    return this.req.method;
-  }
-
-  get url() {
-    return this.req.url || '';
-  }
-
-  set url(val) {
-    this.req.url = val;
-  }
-
-  get host() {
-    let host = this.getReqHeader('X-Forwarded-Host');
-
-    if (!host) {
-      host = this.getReqHeader('Host');
-    }
-
-    return host.split(/\s*,\s*/, 1)[0] || '';
-  }
-
-  get protocol() {
-    if (this.req.socket.encrypted) {
-      return 'https';
-    }
-
-    const proto = this.getReqHeader('X-Forwarded-Proto');
-    return proto ? proto.split(/\s*,\s*/, 1)[0] : 'http';
-  }
-
-  get origin() {
-    return `${this.protocol}://${this.host}`;
-  }
-
-  get href() {
-    return this.origin + this.url;
-  }
-
-  get parsedURL() {
-    const url = new URL(this.req.url, this.origin);
-    return url;
-  }
-
-  get path() {
-    return this.parsedURL.pathname;
-  }
-
-  set path(p) {
-    const url = new URL(this.req.url, this.origin); // this should never happend
-
-    if (!url || !p) {
-      return;
-    }
-
-    if (url.pathname === p) {
-      return;
-    }
-
-    url.pathname = p;
-    this.url = url.toString();
-  }
-
-  get querystring() {
-    if (!this.req) {
-      return '';
-    }
-
-    return this.parsedURL.search.replace(/^\?/, '') || '';
-  }
-
-  get query() {
-    const str = this.querystring;
-    return qs.parse(str);
-  }
-  /* response property */
-
-
-  get status() {
-    return this.res.statusCode;
-  }
-
-  set status(statusCode) {
-    this.res.statusCode = statusCode;
-  }
-  /**
-   * 判断链接是否已经关闭
-   */
-
-
-  resHasHandled() {
-    return this.res.writableEnded;
-  }
-
-  logInfo() {
-    return {
-      headers: this.headers,
-      href: this.href,
-      url: this.url
-    };
-  }
-
-  error(dig, err = '') {
-    const message = toMessage(dig, err);
-    const reqInfo = this.logInfo();
-    this.logger.error(`${reqInfo.url} - ${message}`, reqInfo);
-  }
-
-}

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

@@ -1,3 +0,0 @@
-import { ModernServerContext } from "./context";
-export const createContext = (req, res) => new ModernServerContext(req, res);
-export { ModernServerContext };

package/dist/js/modern/libs/hook-api/route.js

@@ -1,39 +0,0 @@
-class RouteAPI {
-  constructor(matched, router, url) {
-    this.router = void 0;
-    this.current = void 0;
-    this.url = void 0;
-    this.current = matched;
-    this.router = router;
-    this.url = url;
-  }
-
-  cur() {
-    return this.current.generate(this.url);
-  }
-
-  get(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-    return matched ? matched.generate(this.url) : null;
-  }
-
-  use(entryName) {
-    const {
-      router
-    } = this;
-    const matched = router.matchEntry(entryName);
-
-    if (matched) {
-      this.current = matched;
-      return true;
-    } else {
-      return false;
-    }
-  }
-
-}
-
-export const createRouteAPI = (matched, router, url) => new RouteAPI(matched, router, url);

package/dist/js/modern/libs/hook-api/template.js

@@ -1,61 +0,0 @@
-const RegList = {
-  before: {
-    head: '<head>',
-    body: '<body>'
-  },
-  after: {
-    head: '</head>',
-    body: '</body>'
-  }
-};
-
-class TemplateAPI {
-  constructor(content) {
-    this.content = void 0;
-    this.content = content;
-  }
-
-  get() {
-    return this.content;
-  }
-
-  set(content) {
-    this.content = content;
-  }
-
-  prependHead(fragment) {
-    const {
-      head
-    } = RegList.before;
-    return this.replace(head, `${head}${fragment}`);
-  }
-
-  appendHead(fragment) {
-    const {
-      head
-    } = RegList.after;
-    return this.replace(head, `${fragment}${head}`);
-  }
-
-  prependBody(fragment) {
-    const {
-      body
-    } = RegList.before;
-    return this.replace(body, `${body}${fragment}`);
-  }
-
-  appendBody(fragment) {
-    const {
-      body
-    } = RegList.after;
-    return this.replace(body, `${fragment}${body}`);
-  }
-
-  replace(reg, text) {
-    this.content = this.content.replace(reg, text);
-    return this;
-  }
-
-}
-
-export const createTemplateAPI = content => new TemplateAPI(content);

package/dist/js/modern/libs/metrics.js

@@ -1,12 +0,0 @@
-const metrics = {
-  gauges() {// no impl
-  },
-
-  counter() {// no impl
-  },
-
-  timer() {// no impl
-  }
-
-};
-export { metrics };

package/dist/js/modern/libs/proxy.js

@@ -1,33 +0,0 @@
-import { createProxyMiddleware } from 'http-proxy-middleware';
-import { formatProxyOptions } from '@modern-js/utils';
-export const createProxyHandler = proxyOptions => {
-  if (!proxyOptions) {
-    return null;
-  } // If it is not an array, it may be an object that uses the context attribute
-  // or an object in the form of { source: ProxyDetail }
-
-
-  const formatedProxy = formatProxyOptions(proxyOptions);
-  const middlewares = formatedProxy.map(option => {
-    const middleware = createProxyMiddleware(option.context, option); // eslint-disable-next-line consistent-return
-
-    return async (ctx, next) => {
-      const {
-        req,
-        res
-      } = ctx;
-      const bypassUrl = typeof option.bypass === 'function' ? option.bypass(req, res, option) : null; // only false, no true
-
-      if (typeof bypassUrl === 'boolean') {
-        ctx.status = 404;
-        return next();
-      } else if (typeof bypassUrl === 'string') {
-        ctx.url = bypassUrl;
-        return next();
-      }
-
-      middleware(req, res, next);
-    };
-  });
-  return middlewares;
-};