@modern-js/server 1.4.1 → 1.4.4

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

@@ -1,34 +0,0 @@
-/// <reference types="react" />
-import { BaseSSRServerContext } from '@modern-js/types/server';
-declare type MetaKeyMap = {
-  header?: string[];
-  query?: string[];
-};
-declare type MetaKeyMatch = {
-  header?: MatchMap;
-  query?: MatchMap;
-};
-declare type MatchMap = Record<string, Record<string, string>>;
-export declare type CacheConfig = {
-  interval: number;
-  staleLimit: number | boolean;
-  level: number;
-  includes?: MetaKeyMap | null;
-  excludes?: MetaKeyMap | null;
-  matches?: MetaKeyMatch | null;
-};
-export declare enum RenderLevel {
-  CLIENT_RENDER = 0,
-  SERVER_PREFETCH = 1,
-  SERVER_RENDER = 2,
-}
-export declare type SSRServerContext = BaseSSRServerContext & {
-  cacheConfig?: CacheConfig;
-  staticGenerate?: boolean;
-};
-export declare type ModernSSRReactComponent = React.ComponentType<any> & {
-  init: (context: SSRServerContext) => Promise<void>;
-  prefetch: (context: SSRServerContext) => Promise<Record<string, any>>;
-};
-export declare type RenderFunction = (context: SSRServerContext) => Promise<string>;
-export {};

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

@@ -1,15 +0,0 @@
-import { RouteMatcher } from './matcher';
-import { ModernRoute, ModernRouteInterface } from './route';
-export declare class RouteMatchManager {
-  matchers: RouteMatcher[];
-  private specs;
-  constructor();
-  private filter;
-  private best;
-  reset(specs: ModernRouteInterface[]): void;
-  match(pathname: string): RouteMatcher | undefined;
-  matchEntry(entryname: string): RouteMatcher | undefined;
-  getBundles(): (string | undefined)[];
-}
-export type { ModernRouteInterface, ModernRoute };
-export { RouteMatcher };

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

@@ -1,15 +0,0 @@
-import { MatchFunction } from 'path-to-regexp';
-import { ModernRoute, ModernRouteInterface } from './route';
-export declare class RouteMatcher {
-  spec: ModernRouteInterface;
-  urlPath: string;
-  urlMatcher?: MatchFunction;
-  urlReg?: RegExp;
-  constructor(spec: ModernRouteInterface);
-  generate(url: string): ModernRoute;
-  parseURLParams(pathname: string): Record<string, string>;
-  matchLength(pathname: string): number | null;
-  matchUrlPath(requestUrl: string): boolean;
-  matchEntry(entryName: string): boolean;
-  private setupUrlPath;
-}

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

@@ -1,14 +0,0 @@
-import { ServerRoute as ModernRouteInterface } from '@modern-js/types';
-export type { ModernRouteInterface };
-export declare class ModernRoute implements ModernRouteInterface {
-  entryName: string;
-  urlPath: string;
-  entryPath: string;
-  bundle: string;
-  isApi: boolean;
-  isSSR: boolean;
-  isSPA: boolean;
-  enableModernMode?: boolean;
-  params: Record<string, any>;
-  constructor(routeSpec: ModernRouteInterface);
-}

package/dist/types/libs/serve-file.d.ts

@@ -1,8 +0,0 @@
-import { NextFunction } from '../type';
-import { ModernServerContext } from './context';
-declare type Rule = {
-  path: string | RegExp;
-  target: string;
-};
-export declare const createStaticFileHandler: (rules: Rule[]) => (context: ModernServerContext, next: NextFunction) => Promise<void>;
-export {};

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

@@ -1,2 +0,0 @@
-export { ModernAPIDevServer, ModernSSRDevServer } from './dev-server-split';
-export { ModernDevServer } from './dev-server';

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

@@ -1,26 +0,0 @@
-import { APIServerStartInput } from '@modern-js/server-core';
-import { mergeExtension } from '../utils';
-import { ModernRoute, ModernRouteInterface, RouteMatcher } from '../libs/route';
-import { ApiServerMode } from '../constants';
-import { ModernServerContext } from '../libs/context';
-import { ModernServer } from './modern-server';
-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-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-core").Adapter>;
-  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
-  protected preServerInit(): Promise<void>;
-}
-export declare class ModernWebServer extends ModernServer {
-  protected warmupSSRBundle(): Promise<void>;
-  protected handleAPI(context: ModernServerContext): Promise<void>;
-  protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<any>;
-}

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

@@ -1,72 +0,0 @@
-/// <reference types="node" />
-import { IncomingMessage, ServerResponse, Server } from 'http';
-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';
-import { mergeExtension } from '../utils';
-import { ModernServerContext } from '../libs/context';
-import { ApiServerMode } from '../constants';
-declare type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;
-declare type ModernServerAsyncHandler = (context: ModernServerContext, next: NextFunction) => Promise<void>;
-export declare class ModernServer {
-  protected pwd: string;
-  protected distDir: string;
-  protected workDir: string;
-  protected router: RouteMatchManager;
-  protected conf: NormalizedConfig;
-  protected handlers: ModernServerAsyncHandler[];
-  protected presetRoutes?: ModernRouteInterface[];
-  protected runner: ServerHookRunner;
-  protected readonly logger: Logger;
-  protected readonly metrics: Metrics;
-  protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
-  private readonly isDev;
-  private staticFileHandler;
-  private routeRenderHandler;
-  private frameWebHandler;
-  private frameAPIHandler;
-  private proxyHandler;
-  private _handler;
-  private readonly staticGenerate;
-  constructor({
-    pwd,
-    config,
-    dev,
-    routes,
-    staticGenerate,
-    logger,
-    metrics,
-    proxyTarget
-  }: ModernServerOptions);
-  getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
-  init(runner: ServerHookRunner): Promise<void>;
-  ready(_: ReadyOptions): void;
-  onListening(_: Server): void;
-  close(): void;
-  createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server>;
-  protected readRouteSpec(): ModernRouteInterface[];
-  protected addHandler(handler: ModernServerHandler): void;
-  protected render404(context: ModernServerContext): void;
-  protected prepareFrameHandler(): Promise<void>;
-  protected proxy(): Promise<any>;
-  protected prepareWebHandler(extension: ReturnType<typeof mergeExtension>): Promise<Adapter>;
-  protected prepareAPIHandler(mode: ApiServerMode, extension: APIServerStartInput['config']): Promise<Adapter>;
-  protected filterRoutes(routes: ModernRouteInterface[]): ModernRouteInterface[];
-  protected emitRouteHook(eventName: 'beforeMatch' | 'afterMatch' | 'beforeRender' | 'afterRender', input: {
-    context: ModernServerContext;
-    [propsName: string]: any;
-  }): Promise<any>;
-  protected warmupSSRBundle(): void;
-  protected preServerInit(): Promise<void>;
-  protected handleAPI(context: ModernServerContext): Promise<void>;
-  protected handleWeb(context: ModernServerContext, route: ModernRoute): Promise<import("../type").RenderResult | null>;
-  protected verifyMatch(_c: ModernServerContext, _m: RouteMatcher): void;
-  private routeHandler;
-  private injectMicroFE;
-  private compose;
-  private requestHandler;
-  private onError;
-  private renderErrorPage;
-}
-export {};

package/dist/types/type.d.ts

@@ -1,80 +0,0 @@
-/// <reference types="node" />
-import type Webpack from 'webpack';
-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';
-declare module 'http' {
-  interface IncomingMessage {
-    logger: Logger;
-    metrics: Metrics;
-  }
-}
-declare module '@modern-js/core' {
-  interface UserConfig {
-    bff?: {
-      proxy: Record<string, any>;
-    };
-  }
-}
-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 ModernServerOptions = {
-  pwd: string;
-  config: NormalizedConfig;
-  plugins?: {
-    pluginPath: string;
-  }[];
-  dev?: boolean | Partial<DevServerOptions>;
-  compiler?: Webpack.MultiCompiler | Webpack.Compiler | null;
-  routes?: ModernRouteInterface[];
-  staticGenerate?: boolean;
-  customServer?: boolean;
-  loggerOptions?: Record<string, string>;
-  metricsOptions?: Record<string, string>;
-  logger?: Logger;
-  metrics?: Metrics;
-  apiOnly?: boolean;
-  ssrOnly?: boolean;
-  webOnly?: boolean;
-  proxyTarget?: {
-    ssr?: string;
-    api?: string;
-  };
-};
-export declare type RenderResult = {
-  content: string | Buffer;
-  contentType: string;
-  statusCode?: number;
-  redirect?: boolean;
-};
-export declare type ConfWithBFF = {
-  bff?: {
-    prefix: string;
-  };
-} & NormalizedConfig;
-export declare type Then<T> = T extends PromiseLike<infer U> ? U : T;
-export declare type ServerHookRunner = Then<ReturnType<typeof serverManager.init>>;
-export declare type ReadyOptions = {
-  routes?: ModernRouteInterface[];
-};
-export type { Metrics, Logger, NextFunction };

package/dist/types/utils.d.ts

@@ -1,19 +0,0 @@
-import type { NormalizedConfig } from '@modern-js/core';
-export declare const mergeExtension: (users: any[]) => {
-  middleware: any[];
-};
-export declare const toMessage: (dig: string, e: Error | string) => string;
-export declare const noop: () => void;
-export declare const createErrorDocument: (status: number, text: string) => string;
-export declare type CollectMiddlewaresResult = {
-  web: any[];
-  api: any[];
-};
-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/tests/context.test.ts

@@ -1,52 +0,0 @@
-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 context = createContext(req, res);
-    const {
-      method,
-      url,
-      origin,
-      host,
-      path,
-      href,
-      query,
-      querystring,
-      protocol,
-      params,
-    } = context;
-
-    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({});
-
-    expect(context.serverData).toEqual({});
-    context.setServerData('foo', {
-      name: 'foo',
-    });
-    expect(context.serverData).toEqual({
-      foo: {
-        name: 'foo',
-      },
-    });
-  });
-});

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

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

package/tests/fixtures/reader/index.ts

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

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

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

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

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

package/tests/fixtures/ssr/bundle.js

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

package/tests/fixtures/static-dir/bar.html

@@ -1,11 +0,0 @@
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>bar</title>
-</head>
-<body>
-
-</body>
-</html>

package/tests/fixtures/static-dir/baz/index.html

@@ -1,11 +0,0 @@
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>baz</title>
-</head>
-<body>
-
-</body>
-</html>

package/tests/fixtures/static-dir/foo/index.html

@@ -1,11 +0,0 @@
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <meta http-equiv="X-UA-Compatible" content="IE=edge">
-  <meta name="viewport" content="width=device-width, initial-scale=1.0">
-  <title>foo</title>
-</head>
-<body>
-
-</body>
-</html>

package/tests/helper.ts

@@ -1,8 +0,0 @@
-export const createDoc = () => `<html>
-  <head>
-    <title>mock</title>
-  </head>
-  <body>
-    <div>hello</div>
-  </body>
-  </html>`;

package/tests/hook.test.ts

@@ -1,44 +0,0 @@
-import { createRouteAPI } from '../src/libs/hook-api/route';
-import { createTemplateAPI } from '../src/libs/hook-api/template';
-import { RouteMatchManager } from '../src/libs/route';
-import { createDoc } from './helper';
-import spec from './fixtures/route-spec/index.json';
-
-describe('test hook api', () => {
-  test('should route api work correctly', () => {
-    const manager = new RouteMatchManager();
-    manager.reset(spec.routes);
-    const matcher = manager.match('/home');
-
-    const routeAPI = createRouteAPI(matcher!, manager, '');
-    expect(routeAPI.cur().entryName).toBe('home');
-    expect(routeAPI.get('entry')?.entryPath).toBe('html/entry/index.html');
-
-    expect(routeAPI.use('home')).toBeTruthy();
-    expect(routeAPI.cur().entryName).toBe('home');
-  });
-
-  test('should template api work correctly', () => {
-    const content = createDoc();
-    const templateAPI = createTemplateAPI(content);
-
-    expect(templateAPI.get()).toMatch(content);
-
-    templateAPI.replace('mock', 'replace');
-    expect(templateAPI.get()).toMatch('replace');
-
-    templateAPI.appendBody('after body');
-    templateAPI.prependBody('before body');
-    templateAPI.appendHead('after head');
-    templateAPI.prependHead('before head');
-
-    const newContent = templateAPI.get();
-    expect(newContent).toMatch('<head>before head');
-    expect(newContent).toMatch('<body>before body');
-    expect(newContent).toMatch('after head</head>');
-    expect(newContent).toMatch('after body</body>');
-
-    templateAPI.set('<div>empty</div>');
-    expect(templateAPI.get()).toBe('<div>empty</div>');
-  });
-});