@modern-js/server 1.1.4 → 1.2.1-beta.0

package/src/libs/context/context.ts

@@ -3,11 +3,16 @@ import { URL } from 'url';
 import qs from 'querystring';
 import type {
   ModernServerContext as ModernServerContextInterface,
-  Measure,
+  Metrics,
   Logger,
 } from '@modern-js/types/server';
 import { toMessage } from '../../utils';
 
+export type ContextOptions = {
+  logger?: Logger;
+  metrics?: Metrics;
+};
+
 export class ModernServerContext implements ModernServerContextInterface {
   /**
    * http request
@@ -26,17 +31,21 @@ export class ModernServerContext implements ModernServerContextInterface {
 
   public logger: Logger;
 
-  public measure?: Measure;
+  public metrics?: Metrics;
 
-  constructor(
-    req: IncomingMessage,
-    res: ServerResponse,
-    { logger, measure }: { logger: Logger; measure: Measure },
-  ) {
+  constructor(req: IncomingMessage, res: ServerResponse) {
     this.req = req;
     this.res = res;
-    this.logger = logger;
-    this.measure = measure;
+    this.logger = req.logger;
+    this.metrics = req.metrics;
+
+    this.bind();
+  }
+
+  private bind() {
+    const { req, res } = this as any;
+    req.get = (key: string) => this.getReqHeader(key);
+    res.set = (key: string, value: any) => this.res.setHeader(key, value);
   }
 
   public setParams(params: Record<string, string>) {
@@ -60,10 +69,6 @@ export class ModernServerContext implements ModernServerContextInterface {
     return this.req.headers;
   }
 
-  public set headers(val) {
-    this.req.headers = val;
-  }
-
   public get method(): string {
     return this.req.method!;
   }

package/src/libs/context/index.ts

@@ -1,11 +1,7 @@
 import { IncomingMessage, ServerResponse } from 'http';
-import { Measure, Logger } from '../../type';
 import { ModernServerContext } from './context';
 
-export const createContext = (
-  req: IncomingMessage,
-  res: ServerResponse,
-  { logger, measure }: { logger: Logger; measure: Measure },
-) => new ModernServerContext(req, res, { logger, measure });
+export const createContext = (req: IncomingMessage, res: ServerResponse) =>
+  new ModernServerContext(req, res);
 
 export { ModernServerContext };

package/src/libs/{measure.ts → metrics.ts}

@@ -1,6 +1,6 @@
-import { Measure } from '@/type';
+import { Metrics } from '@/type';
 
-const measure: Measure = {
+const metrics: Metrics = {
   gauges() {
     // no impl
   },
@@ -12,4 +12,4 @@ const measure: Measure = {
   },
 };
 
-export { measure };
+export { metrics };

package/src/libs/proxy.ts

@@ -54,7 +54,7 @@ export const createProxyHandler = (proxyOptions: ProxyOptions) => {
       );
     }
   } else {
-    formatedProxy.concat(proxyOptions);
+    formatedProxy.push(...proxyOptions);
   }
 
   const middlewares = formatedProxy.map(option => {

package/src/libs/render/cache/__tests__/cache.test.ts

@@ -15,6 +15,8 @@ const createCacheConfig = (config: any = {}) => ({
   ...config,
 });
 
+jest.setTimeout(60000);
+
 describe('cache', () => {
   it('should cache correctly', async () => {
     destroyCache();
@@ -179,7 +181,6 @@ describe('cache', () => {
     }
   });
 
-  jest.setTimeout(1000 * 10);
   it('should stale cache correctly', async () => {
     destroyCache();
     const cache = createCache();
@@ -207,7 +208,6 @@ describe('cache', () => {
     expect(staleResult?.isStale).toBe(true);
   });
 
-  jest.setTimeout(1000 * 15);
   it('should garbage cache correctly', async () => {
     destroyCache();
     const cache = createCache();

package/src/libs/render/index.ts

@@ -9,6 +9,7 @@ import { readFile } from './reader';
 import * as ssr from './ssr';
 import { supportModern, getModernEntry } from './modern';
 import { ERROR_DIGEST } from '@/constants';
+import { ServerHookRunner } from '@/type';
 
 export const createRenderHandler = ({
   distDir,
@@ -17,10 +18,15 @@ export const createRenderHandler = ({
   distDir: string;
   staticGenerate: boolean;
 }) =>
-  async function render(
-    ctx: ModernServerContext,
-    route: ModernRoute,
-  ): Promise<RenderResult | null> {
+  async function render({
+    ctx,
+    route,
+    runner,
+  }: {
+    ctx: ModernServerContext;
+    route: ModernRoute;
+    runner: ServerHookRunner;
+  }): Promise<RenderResult | null> {
     if (ctx.resHasHandled()) {
       return null;
     }
@@ -43,13 +49,17 @@ export const createRenderHandler = ({
     // handles ssr first
     if (route.isSSR) {
       try {
-        const result = await ssr.render(ctx, {
-          distDir,
-          entryName: route.entryName,
-          bundle: route.bundle,
-          template: templateHTML,
-          staticGenerate,
-        });
+        const result = await ssr.render(
+          ctx,
+          {
+            distDir,
+            entryName: route.entryName,
+            bundle: route.bundle,
+            template: templateHTML,
+            staticGenerate,
+          },
+          runner,
+        );
         return result;
       } catch (err) {
         ctx.error(ERROR_DIGEST.ERENDER, (err as Error).stack);

package/src/libs/render/reader.ts

@@ -24,7 +24,7 @@ const createCacheItem = async (filepath: string, mtime: Date) => {
 class LruReader {
   private readonly cache: LRU<string, FileCache>;
 
-  private timer?: NodeJS.Timeout;
+  // private timer?: NodeJS.Timeout;
 
   constructor() {
     this.cache = new LRU({
@@ -35,13 +35,13 @@ class LruReader {
   }
 
   public init() {
-    this.timeTask();
+    // this.timeTask();
   }
 
   public close() {
-    if (this.timer) {
-      clearInterval(this.timer);
-    }
+    // if (this.timer) {
+    //   clearInterval(this.timer);
+    // }
   }
 
   public async read(filepath: string) {
@@ -94,9 +94,9 @@ class LruReader {
     }
   }
 
-  private timeTask() {
-    this.timer = setInterval(() => this.update, 5 * 60 * 1000).unref();
-  }
+  // private timeTask() {
+  // this.timer = setInterval(() => this.update, 5 * 60 * 1000).unref();
+  // }
 }
 
 const reader = new LruReader();

package/src/libs/render/ssr.ts

@@ -5,6 +5,7 @@ import { ModernServerContext } from '../context';
 import { RenderResult } from '../../type';
 import cache from './cache';
 import { SSRServerContext } from './type';
+import { ServerHookRunner } from '@/type';
 
 export const render = async (
   ctx: ModernServerContext,
@@ -15,6 +16,7 @@ export const render = async (
     entryName: string;
     staticGenerate: boolean;
   },
+  runner: ServerHookRunner,
 ): Promise<RenderResult> => {
   const { bundle, distDir, template, entryName, staticGenerate } =
     renderOptions;
@@ -34,9 +36,11 @@ export const render = async (
     distDir,
     staticGenerate,
     logger: ctx.logger,
-    measure: ctx.measure,
+    metrics: ctx.metrics,
   };
 
+  runner.extendSSRContext(context);
+
   const serverRender = require(bundleJS)[SERVER_RENDER_FUNCTION_NAME];
 
   const html = await cache(serverRender, ctx)(context);

package/src/libs/render/type.ts

@@ -1,5 +1,4 @@
-import { IncomingHttpHeaders } from 'http';
-import { Measure, Logger } from '../../type';
+import { BaseSSRServerContext } from '@modern-js/types/server';
 
 type MetaKeyMap = {
   header?: string[];
@@ -26,21 +25,7 @@ export enum RenderLevel {
   SERVER_RENDER,
 }
 
-export type SSRServerContext = {
-  request: {
-    params: Record<string, string>;
-    pathname: string;
-    query: Record<string, string>;
-    headers: IncomingHttpHeaders;
-    cookie?: string;
-  };
-  redirection: { url?: string; status?: number };
-  distDir: string;
-  template: string;
-  entryName: string;
-  logger: Logger;
-  measure?: Measure;
-  loadableManifest?: string;
+export type SSRServerContext = BaseSSRServerContext & {
   cacheConfig?: CacheConfig;
   staticGenerate?: boolean;
 };

package/src/libs/route/index.ts

@@ -73,4 +73,5 @@ export class RouteMatchManager {
   }
 }
 
-export type { ModernRouteInterface, RouteMatcher, ModernRoute };
+export type { ModernRouteInterface, ModernRoute };
+export { RouteMatcher };

package/src/libs/route/route.ts

@@ -1,22 +1,6 @@
-export interface ModernRouteInterface {
-  // modern js web entry name
-  entryName: string;
-  // the url path for request match
-  urlPath: string;
-  // the default resource file to response to route
-  entryPath?: string;
-  // if route is spa page
-  isSPA?: boolean;
-  // if route is ssr page
-  isSSR?: boolean;
-  // if route is api service
-  isApi?: boolean;
-  // ssr js bundle for ssr page
-  bundle?: string;
-  // if route has modern product
-  enableModernMode?: boolean;
-  // specialHeader?: SpecialHeader[];
-}
+import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
+
+export type { ModernRouteInterface };
 
 export class ModernRoute implements ModernRouteInterface {
   public entryName: string;
@@ -36,7 +20,7 @@ export class ModernRoute implements ModernRouteInterface {
   public enableModernMode?: boolean;
 
   constructor(routeSpec: ModernRouteInterface) {
-    this.entryName = routeSpec.entryName;
+    this.entryName = routeSpec.entryName || '';
     this.urlPath = routeSpec.urlPath;
     this.entryPath = routeSpec.entryPath || '';
     this.isSSR = routeSpec.isSSR || false;

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

@@ -43,9 +43,11 @@ const DEFAULT_DEV_OPTIONS: DevServerOptions = {
   },
   https: false,
   dev: { writeToDisk: true },
+  watch: true,
   hot: true,
   liveReload: true,
 };
+
 export class ModernDevServer extends ModernServer {
   private devProxyHandler: ReturnType<typeof createProxyHandler> = null;
 
@@ -72,7 +74,9 @@ export class ModernDevServer extends ModernServer {
 
     // set dev server options, like webpack-dev-server
     this.dev =
-      typeof options.dev === 'boolean' ? DEFAULT_DEV_OPTIONS : options.dev!;
+      typeof options.dev === 'boolean'
+        ? DEFAULT_DEV_OPTIONS
+        : { ...DEFAULT_DEV_OPTIONS, ...options.dev };
 
     enableRegister(this.pwd, this.conf);
   }
@@ -120,7 +124,9 @@ export class ModernDevServer extends ModernServer {
     await super.init(runner);
 
     // watch mock/ server/ api/ dir file change
-    this.startWatcher();
+    if (this.dev.watch) {
+      this.startWatcher();
+    }
   }
 
   public ready(options: ReadyOptions = {}) {

package/src/server/index.ts

@@ -18,7 +18,7 @@ import {
   ModernWebServer,
 } from './modern-server-split';
 import { ModernServerOptions, ServerHookRunner, ReadyOptions } from '@/type';
-import { measure as defaultMeasure } from '@/libs/measure';
+import { metrics as defaultMetrics } from '@/libs/metrics';
 
 export class Server {
   public options: ModernServerOptions;
@@ -48,7 +48,7 @@ export class Server {
     const { options } = this;
 
     options.logger = options.logger || defaultLogger;
-    options.measure = options.measure || defaultMeasure;
+    options.metrics = options.metrics || defaultMetrics;
 
     // initialize server
     if (options.dev) {
@@ -135,7 +135,7 @@ export class Server {
         ...appContext,
         distDirectory: path.join(
           options.pwd,
-          options.config.output.path || 'dist',
+          options.config.output?.path || 'dist',
         ),
       });
     });

package/src/server/modern-server.ts

@@ -12,7 +12,7 @@ import {
   ModernServerOptions,
   NextFunction,
   ServerHookRunner,
-  Measure,
+  Metrics,
   Logger,
   ReadyOptions,
   ConfWithBFF,
@@ -73,7 +73,7 @@ export class ModernServer {
 
   protected readonly logger: Logger;
 
-  protected readonly measure: Measure;
+  protected readonly metrics: Metrics;
 
   protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
 
@@ -87,12 +87,12 @@ export class ModernServer {
 
   private frameAPIHandler: Adapter | null = null;
 
+  private proxyHandler: ReturnType<typeof createProxyHandler> = null;
+
   private _handler!: (context: ModernServerContext, next: NextFunction) => void;
 
   private readonly staticGenerate: boolean = false;
 
-  private proxyHandler: ReturnType<typeof createProxyHandler> = null;
-
   constructor({
     pwd,
     config,
@@ -100,18 +100,18 @@ export class ModernServer {
     routes,
     staticGenerate,
     logger,
-    measure,
+    metrics,
     proxyTarget,
   }: ModernServerOptions) {
     require('ignore-styles');
     this.isDev = Boolean(dev);
 
     this.pwd = pwd;
-    this.distDir = path.join(pwd, config.output.path || 'dist');
+    this.distDir = path.join(pwd, config.output?.path || 'dist');
     this.workDir = this.isDev ? pwd : this.distDir;
     this.conf = config;
     this.logger = logger!;
-    this.measure = measure!;
+    this.metrics = metrics!;
     this.router = new RouteMatchManager();
     this.presetRoutes = routes;
     this.proxyTarget = proxyTarget;
@@ -162,7 +162,7 @@ export class ModernServer {
 
     await this.prepareFrameHandler();
 
-    const { favicon, faviconByEntries } = this.conf.output;
+    const { favicon, faviconByEntries } = this.conf.output || {};
     const favicons = this.prepareFavicons(favicon, faviconByEntries);
     // Only work when without setting `assetPrefix`.
     // Setting `assetPrefix` means these resources should be uploaded to CDN.
@@ -356,7 +356,11 @@ export class ModernServer {
   }
 
   protected async handleWeb(context: ModernServerContext, route: ModernRoute) {
-    return this.routeRenderHandler(context, route);
+    return this.routeRenderHandler({
+      ctx: context,
+      route,
+      runner: this.runner,
+    });
   }
 
   protected verifyMatch(_c: ModernServerContext, _m: RouteMatcher) {
@@ -372,7 +376,7 @@ export class ModernServer {
     await this.emitRouteHook('beforeMatch', { context });
 
     // match routes in the route spec
-    const matched = this.router.match(context.url);
+    const matched = this.router.match(context.path);
     if (!matched) {
       this.render404(context);
       return;
@@ -546,10 +550,9 @@ export class ModernServer {
     },
   ) {
     res.statusCode = 200;
-    const context: ModernServerContext = createContext(req, res, {
-      logger: this.logger,
-      measure: this.measure,
-    });
+    req.logger = req.logger || this.logger;
+    req.metrics = req.metrics || this.metrics;
+    const context: ModernServerContext = createContext(req, res);
 
     try {
       this._handler(context, next);
@@ -580,7 +583,11 @@ export class ModernServer {
       // check entryName, aviod matched '/' route
       if (entryName === status.toString() || entryName === '_error') {
         try {
-          const file = await this.routeRenderHandler(context, route);
+          const file = await this.routeRenderHandler({
+            route,
+            ctx: context,
+            runner: this.runner,
+          });
           if (file) {
             context.res.end(file.content);
             return;

package/src/type.ts

@@ -2,9 +2,16 @@ import { Buffer } from 'buffer';
 import type Webpack from 'webpack';
 import { serverManager } from '@modern-js/server-plugin';
 import type { NormalizedConfig } from '@modern-js/core';
-import type { Measure, Logger, NextFunction } from '@modern-js/types/server';
+import type { Metrics, Logger, NextFunction } from '@modern-js/types/server';
 import { ModernRouteInterface } from './libs/route';
 
+declare module 'http' {
+  interface IncomingMessage {
+    logger: Logger;
+    metrics: Metrics;
+  }
+}
+
 declare module '@modern-js/core' {
   interface UserConfig {
     bff: {
@@ -26,6 +33,8 @@ export type DevServerOptions = {
   dev: {
     writeToDisk: boolean | ((filename: string) => boolean);
   };
+  // 是否监听文件变化
+  watch: boolean;
   // 是否开启 hot reload
   hot: boolean | string;
   // 是否开启 page reload
@@ -39,15 +48,15 @@ export type ModernServerOptions = {
   pwd: string;
   config: NormalizedConfig;
   plugins?: any[];
-  dev?: boolean | DevServerOptions;
+  dev?: boolean | Partial<DevServerOptions>;
   compiler?: Webpack.MultiCompiler | Webpack.Compiler;
   routes?: ModernRouteInterface[];
   staticGenerate?: boolean;
   customServer?: boolean;
   loggerOptions?: Record<string, string>;
-  measureOptions?: Record<string, string>;
+  metricsOptions?: Record<string, string>;
   logger?: Logger;
-  measure?: Measure;
+  metrics?: Metrics;
   apiOnly?: boolean;
   ssrOnly?: boolean;
   webOnly?: boolean;
@@ -76,4 +85,4 @@ export type ServerHookRunner = Then<ReturnType<typeof serverManager.init>>;
 
 export type ReadyOptions = { routes?: ModernRouteInterface[] };
 
-export type { Measure, Logger, NextFunction };
+export type { Metrics, Logger, NextFunction };

package/src/utils.ts

@@ -49,17 +49,3 @@ export const createErrorDocument = (status: number, text: string) => {
   </html>
   `;
 };
-
-// This can live anywhere in your codebase:
-export function applyMixins(derivedCtor: any, constructors: any[]) {
-  constructors.forEach(baseCtor => {
-    Object.getOwnPropertyNames(baseCtor.prototype).forEach(name => {
-      Object.defineProperty(
-        derivedCtor.prototype,
-        name,
-        Object.getOwnPropertyDescriptor(baseCtor.prototype, name) ||
-          Object.create(null),
-      );
-    });
-  });
-}

package/tests/.eslintrc.js

@@ -0,0 +1,6 @@
+module.exports = {
+  extends: ['@modern-js'],
+  parserOptions: {
+    project: require.resolve('./tsconfig.json'),
+  },
+};

package/tests/context.test.ts

@@ -0,0 +1,41 @@
+import EventEmitter from 'events';
+import { Readable } from 'stream';
+import httpMocks from 'node-mocks-http';
+import { createContext } from '../src/libs/context';
+
+describe('test server context', () => {
+  test('should route api work correctly', () => {
+    const req = httpMocks.createRequest({
+      url: '/pathname?foo=baz',
+      headers: {
+        host: 'modernjs.com',
+      },
+      eventEmitter: Readable,
+      method: 'GET',
+    });
+    const res = httpMocks.createResponse({ eventEmitter: EventEmitter });
+    const {
+      method,
+      url,
+      origin,
+      host,
+      path,
+      href,
+      query,
+      querystring,
+      protocol,
+      params,
+    } = createContext(req, res);
+
+    expect(method).toBe('GET');
+    expect(url).toBe('/pathname?foo=baz');
+    expect(origin).toBe('http://modernjs.com');
+    expect(host).toBe('modernjs.com');
+    expect(path).toBe('/pathname');
+    expect(href).toBe('http://modernjs.com/pathname?foo=baz');
+    expect(query).toEqual({ foo: 'baz' });
+    expect(querystring).toBe('foo=baz');
+    expect(protocol).toBe('http');
+    expect(params).toEqual({});
+  });
+});

package/tests/fixtures/hosting-files/static/index.js

@@ -0,0 +1 @@
+console.info('index.js');

package/tests/fixtures/pure/modern.config.js

@@ -0,0 +1,5 @@
+module.exports = {
+  server: {
+    ssr: true,
+  },
+};

package/tests/fixtures/pure/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "deploy",
+  "version": "0.1.0",
+  "scripts": {
+    "reset": "del-cli node_modules",
+    "dev": "modern dev",
+    "build": "modern build",
+    "start": "modern start",
+    "new": "modern new",
+    "lint": "modern lint",
+    "deploy": "modern deploy"
+  },
+  "dependencies": {},
+  "devDependencies": {},
+  "modernConfig": {
+    "runtime": {
+      "router": true,
+      "state": true
+    }
+  }
+}