@modern-js/prod-server 2.9.1-alpha.0 → 2.11.0

package/dist/esm-node/server/modernServer.js

@@ -27,7 +27,6 @@ import {
 import * as reader from "../libs/render/reader";
 import { createProxyHandler } from "../libs/proxy";
 import { createContext } from "../libs/context";
-import { templateInjectableStream } from "../libs/hook-api/template";
 import {
   AGGRED_DIR,
   ERROR_DIGEST,
@@ -53,7 +52,7 @@ class ModernServer {
   }) {
     this.handlers = [];
     this.reader = reader;
-    this.beforeRouteHandler = null;
+    this.loaderHandler = null;
     this.frameWebHandler = null;
     this.frameAPIHandler = null;
     this.proxyHandler = null;
@@ -91,7 +90,7 @@ class ModernServer {
     this.router.reset(usageRoutes);
     this.warmupSSRBundle();
     await this.prepareFrameHandler();
-    await this.prepareBeforeRouteHandler(usageRoutes, distDir);
+    await this.prepareLoaderHandler(usageRoutes, distDir);
     const ssrConfig = (_b = this.conf.server) == null ? void 0 : _b.ssr;
     const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
     this.routeRenderHandler = createRenderHandler({
@@ -102,24 +101,12 @@ class ModernServer {
     await this.setupBeforeProdMiddleware();
     this.addHandler(this.setupStaticMiddleware((_c = this.conf.output) == null ? void 0 : _c.assetPrefix));
     this.addHandler(faviconFallbackHandler);
-    this.addBeforeRouteHandler();
     this.addHandler(this.routeHandler.bind(this));
     this.compose();
   }
   // server ready
   onRepack(_) {
   }
-  addBeforeRouteHandler() {
-    this.addHandler(async (context, next) => {
-      if (this.beforeRouteHandler) {
-        await this.beforeRouteHandler(context);
-        if (this.isSend(context.res)) {
-          return;
-        }
-      }
-      return next();
-    });
-  }
   onServerChange({ filepath }) {
     const { pwd } = this;
     const { api, server } = AGGRED_DIR;
@@ -146,6 +133,9 @@ class ModernServer {
     if (!result) {
       return null;
     }
+    if (result.contentStream) {
+      return result.contentStream;
+    }
     return result.content.toString();
   }
   async createHTTPServer(handler) {
@@ -174,9 +164,9 @@ class ModernServer {
     context.error(ERROR_DIGEST.ENOTF, "404 Not Found");
     this.renderErrorPage(context, 404);
   }
-  async prepareBeforeRouteHandler(specs, distDir) {
+  async prepareLoaderHandler(specs, distDir) {
     const { runner } = this;
-    const handler = await runner.preparebeforeRouteHandler(
+    const handler = await runner.prepareLoaderHandler(
       {
         serverRoutes: specs,
         distDir
@@ -185,7 +175,7 @@ class ModernServer {
         onLast: () => null
       }
     );
-    this.beforeRouteHandler = handler;
+    this.loaderHandler = handler;
   }
   // gather frame extension and get framework handler
   async prepareFrameHandler(options) {
@@ -271,11 +261,48 @@ class ModernServer {
     await this.frameAPIHandler(req, res);
   }
   async handleWeb(context, route) {
-    return this.routeRenderHandler({
+    const { res } = context;
+    if (this.loaderHandler) {
+      await this.loaderHandler(context);
+      if (this.isSend(res)) {
+        return null;
+      }
+    }
+    context.setParams(route.params);
+    context.setServerData("router", {
+      baseUrl: route.urlPath,
+      params: route.params
+    });
+    if (route.responseHeaders) {
+      Object.keys(route.responseHeaders).forEach((key) => {
+        const value = route.responseHeaders[key];
+        if (value) {
+          context.res.setHeader(key, value);
+        }
+      });
+    }
+    const renderResult = await this.routeRenderHandler({
       ctx: context,
       route,
       runner: this.runner
     });
+    if (!renderResult) {
+      this.render404(context);
+      return null;
+    }
+    if (renderResult.redirect) {
+      this.redirect(
+        res,
+        renderResult.content,
+        renderResult.statusCode
+      );
+      return null;
+    }
+    if (this.isSend(res)) {
+      return null;
+    }
+    res.setHeader("content-type", renderResult.contentType);
+    return renderResult;
   }
   async proxy() {
     return null;
@@ -308,31 +335,31 @@ class ModernServer {
       await this.handleAPI(context);
       return;
     }
-    const afterMatchContext = createAfterMatchContext(context, route.entryName);
-    if (this.runMode === RUN_MODE.FULL) {
-      await this.runner.afterMatch(afterMatchContext, { onLast: noop });
-    }
-    if (this.isSend(res)) {
-      return;
-    }
-    const { current, url, status } = afterMatchContext.router;
-    if (url) {
-      this.redirect(res, url, status);
-      return;
-    }
-    if (route.entryName !== current) {
-      const matched2 = this.router.matchEntry(current);
-      if (!matched2) {
-        this.render404(context);
+    if (route.entryName) {
+      const afterMatchContext = createAfterMatchContext(
+        context,
+        route.entryName
+      );
+      if (this.runMode === RUN_MODE.FULL) {
+        await this.runner.afterMatch(afterMatchContext, { onLast: noop });
+      }
+      if (this.isSend(res)) {
         return;
       }
-      route = matched2.generate(context.url);
+      const { current, url, status } = afterMatchContext.router;
+      if (url) {
+        this.redirect(res, url, status);
+        return;
+      }
+      if (route.entryName !== current) {
+        const matched2 = this.router.matchEntry(current);
+        if (!matched2) {
+          this.render404(context);
+          return;
+        }
+        route = matched2.generate(context.url);
+      }
     }
-    context.setParams(route.params);
-    context.setServerData("router", {
-      baseUrl: route.urlPath,
-      params: route.params
-    });
     if (this.frameWebHandler) {
       res.locals = res.locals || {};
       const middlewareContext = createMiddlewareContext(context);
@@ -341,47 +368,20 @@ class ModernServer {
         ...res.locals,
         ...middlewareContext.response.locals
       };
-    }
-    if (this.isSend(res)) {
-      return;
-    }
-    if (route.responseHeaders) {
-      Object.keys(route.responseHeaders).forEach((key) => {
-        const value = route.responseHeaders[key];
-        if (value) {
-          context.res.setHeader(key, value);
-        }
-      });
+      if (this.isSend(res)) {
+        return;
+      }
     }
     const renderResult = await this.handleWeb(context, route);
     if (!renderResult) {
-      this.render404(context);
-      return;
-    }
-    if (renderResult.redirect) {
-      this.redirect(
-        res,
-        renderResult.content,
-        renderResult.statusCode
-      );
       return;
     }
-    if (this.isSend(res)) {
+    const { contentStream: responseStream } = renderResult;
+    let { content: response } = renderResult;
+    if (route.entryName && responseStream) {
+      responseStream.pipe(res);
       return;
     }
-    res.setHeader("content-type", renderResult.contentType);
-    const { contentStream } = renderResult;
-    if (contentStream) {
-      contentStream.pipe(
-        templateInjectableStream({
-          prependHead: route.entryName ? `<script>window._SERVER_DATA=${JSON.stringify(
-            context.serverData
-          )}</script>` : void 0
-        })
-      ).pipe(res);
-      return;
-    }
-    let response = renderResult.content;
     if (route.entryName) {
       const afterRenderContext = createAfterRenderContext(
         context,
@@ -393,11 +393,6 @@ class ModernServer {
       if (this.isSend(res)) {
         return;
       }
-      afterRenderContext.template.prependHead(
-        `<script>window._SERVER_DATA=${JSON.stringify(
-          context.serverData
-        )}</script>`
-      );
       response = afterRenderContext.template.get();
     }
     res.end(response);

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

@@ -2,7 +2,7 @@
 /// <reference types="node" />
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/gxxotyts4i9oiicydl5gf/src/type" />
+/// <reference types=".dts-temp/k52V3rAmkkpigea7EM0nH/src/type" />
 import { IncomingMessage, ServerResponse } from 'http';
 import qs from 'querystring';
 import type { ModernServerContext as ModernServerContextInterface } from '@modern-js/types';

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

@@ -0,0 +1,5 @@
+/// <reference types="node" />
+import { Readable } from 'stream';
+import type { ModernServerContext } from '@modern-js/types';
+export declare const injectSeverData: (content: string, context: ModernServerContext) => string;
+export declare const injectServerDataStream: (content: Readable, context: ModernServerContext) => import("stream").Transform;

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

@@ -1,5 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node" />
+/// <reference types="node" />
 import { IncomingMessage, ServerResponse } from 'http';
 import type { ListenOptions } from 'net';
 import { ModernServerOptions, ServerConstructor } from '../type';
@@ -45,7 +46,7 @@ export declare class Server {
   close(): Promise<void>;
   listen<T extends number | ListenOptions | undefined>(options: T, listener: any): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
-  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | null>;
+  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | import("stream").Readable | null>;
   private createHookRunner;
   private injectContext;
   private initAppContext;

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

@@ -1,4 +1,5 @@
 /// <reference types="node" />
+/// <reference types="node" />
 import { IncomingMessage, ServerResponse, Server } from 'http';
 import { Adapter, WebAdapter, APIServerStartInput, ServerOptions } from '@modern-js/server-core';
 import type { ModernServerContext, ServerRoute } from '@modern-js/types';
@@ -23,7 +24,7 @@ export declare class ModernServer implements ModernServerInterface {
   protected reader: typeof reader;
   protected readonly proxyTarget: ModernServerOptions['proxyTarget'];
   private routeRenderHandler;
-  private beforeRouteHandler;
+  private loaderHandler;
   private frameWebHandler;
   private frameAPIHandler;
   private proxyHandler;
@@ -41,19 +42,18 @@ export declare class ModernServer implements ModernServerInterface {
   }: ModernServerOptions);
   onInit(runner: ServerHookRunner, app: Server): Promise<void>;
   onRepack(_: BuildOptions): void;
-  addBeforeRouteHandler(): void;
   protected onServerChange({
     filepath
   }: {
     filepath: string;
   }): void;
   getRequestHandler(): (req: IncomingMessage, res: ServerResponse, next?: () => void) => void | ServerResponse;
-  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | null>;
+  render(req: IncomingMessage, res: ServerResponse, url?: string): Promise<string | import("stream").Readable | null>;
   createHTTPServer(handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void): Promise<Server<typeof IncomingMessage, typeof ServerResponse>>;
   protected getRoutes(): ServerRoute[];
   protected addHandler(handler: ModernServerHandler): void;
   protected render404(context: ModernServerContext): void;
-  protected prepareBeforeRouteHandler(specs: ServerRoute[], distDir: string): Promise<void>;
+  protected prepareLoaderHandler(specs: ServerRoute[], distDir: string): Promise<void>;
   protected prepareFrameHandler(options?: {
     onlyApi: boolean;
     onlyWeb: boolean;

package/dist/types/type.d.ts

@@ -61,7 +61,7 @@ export interface ModernServerInterface {
   onRepack: (options: BuildOptions) => void;
   getRequestHandler: () => (req: IncomingMessage, res: ServerResponse, next?: () => void) => void;
   createHTTPServer: (handler: (req: IncomingMessage, res: ServerResponse, next?: () => void) => void) => Promise<Server>;
-  render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | null>;
+  render: (req: IncomingMessage, res: ServerResponse, url?: string) => Promise<string | Readable | null>;
 }
 export type ServerConstructor = (options: ModernServerOptions) => ModernServerInterface;
 export type ModernServerHandler = (context: ModernServerContext, next: NextFunction) => Promise<void> | void;

package/dist/types/utils.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="node" />
 /// <reference types="node/http" />
-/// <reference types=".dts-temp/gxxotyts4i9oiicydl5gf/src/type" />
+/// <reference types=".dts-temp/k52V3rAmkkpigea7EM0nH/src/type" />
 import { IncomingMessage } from 'http';
 import type { OutputNormalizedConfig, HtmlNormalizedConfig } from '@modern-js/server-core';
 export declare const debug: any;

package/package.json

@@ -11,7 +11,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.9.1-alpha.0",
+  "version": "2.11.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -23,6 +23,7 @@
         "import": "./dist/esm-node/index.js",
         "require": "./dist/cjs/index.js"
       },
+      "types": "./dist/types/index.d.ts",
       "default": "./dist/esm/index.js"
     },
     "./worker": {
@@ -31,6 +32,7 @@
         "import": "./dist/esm-node/workerServer.js",
         "require": "./dist/cjs/workerServer.js"
       },
+      "types": "./dist/types/workerServer.d.ts",
       "default": "./dist/esm/workerServer.js"
     }
   },
@@ -54,8 +56,8 @@
     "merge-deep": "^3.0.3",
     "path-to-regexp": "^6.2.0",
     "serve-static": "^1.14.1",
-    "@modern-js/utils": "2.9.0",
-    "@modern-js/server-core": "2.9.0"
+    "@modern-js/utils": "2.11.0",
+    "@modern-js/server-core": "2.11.0"
   },
   "devDependencies": {
     "@types/cookie": "^0.4.1",
@@ -71,10 +73,10 @@
     "node-mocks-http": "^1.11.0",
     "portfinder": "^1.0.28",
     "typescript": "^4",
-    "@modern-js/types": "2.9.0",
-    "@modern-js/server-core": "2.9.0",
-    "@scripts/jest-config": "2.9.0",
-    "@scripts/build": "2.9.0"
+    "@modern-js/types": "2.11.0",
+    "@modern-js/server-core": "2.11.0",
+    "@scripts/jest-config": "2.11.0",
+    "@scripts/build": "2.11.0"
   },
   "sideEffects": false,
   "publishConfig": {

package/dist/js/modern/constants.js

@@ -1,35 +0,0 @@
-const AGGRED_DIR = {
-  mock: "config/mock",
-  server: "server",
-  api: "api",
-  shared: "shared",
-  lambda: "lambda"
-};
-var ApiServerMode = /* @__PURE__ */ ((ApiServerMode2) => {
-  ApiServerMode2["func"] = "function";
-  ApiServerMode2["frame"] = "framework";
-  return ApiServerMode2;
-})(ApiServerMode || {});
-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"
-};
-const ERROR_PAGE_TEXT = {
-  404: "This page could not be found.",
-  500: "Internal Server Error."
-};
-const RUN_MODE = {
-  FULL: "full",
-  TYPE: "type"
-};
-export {
-  AGGRED_DIR,
-  ApiServerMode,
-  ERROR_DIGEST,
-  ERROR_PAGE_TEXT,
-  RUN_MODE
-};

package/dist/js/modern/index.js

@@ -1,18 +0,0 @@
-import { Server } from "./server";
-import { ModernServer } from "./server/modern-server";
-import { createProxyHandler } from "./libs/proxy";
-export * from "./type";
-export * from "./constants";
-var src_default = (options) => {
-  if (options == null) {
-    throw new Error("can not start mserver without options");
-  }
-  const server = new Server(options);
-  return server.init();
-};
-export {
-  ModernServer,
-  Server,
-  createProxyHandler,
-  src_default as default
-};

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

@@ -1,160 +0,0 @@
-import { URL } from "url";
-import qs from "querystring";
-import { Buffer } from "buffer";
-import createEtag from "etag";
-import fresh from "fresh";
-import { headersWithoutCookie } from "../../utils";
-class ModernServerContext {
-  constructor(req, res, options) {
-    this.params = {};
-    this.options = {};
-    this.req = req;
-    this.res = res;
-    this.options = options || {};
-    this.serverData = {};
-    this.bind();
-  }
-  get logger() {
-    return this.req.logger;
-  }
-  get metrics() {
-    return this.req.metrics;
-  }
-  bind() {
-    const { req, res } = this;
-    req.get = (key) => this.getReqHeader(key);
-    res.set = (key, value) => this.res.setHeader(key, value);
-    res.send = (body) => {
-      this.send(body);
-    };
-  }
-  send(body) {
-    try {
-      const generateETag = !this.res.getHeader("ETag") && this.options.etag;
-      if (body !== void 0 && generateETag) {
-        const encoding = typeof body === "string" ? "utf-8" : void 0;
-        const buf = !Buffer.isBuffer(body) ? Buffer.from(body, encoding) : body;
-        const etag = createEtag(buf, { weak: true });
-        if (etag) {
-          this.res.setHeader("ETag", etag);
-        }
-      }
-      if (this.fresh) {
-        this.status = 304;
-      }
-    } catch (e) {
-      this.logger.error(e.message);
-    }
-    this.res.end(body);
-  }
-  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] || "";
-    }
-  }
-  get fresh() {
-    const { status, res, method } = this;
-    if ("GET" !== method && "HEAD" !== method) {
-      return false;
-    }
-    if (status >= 200 && status < 300 || 304 === status) {
-      return fresh(this.headers, {
-        etag: res.getHeader("ETag"),
-        "last-modified": res.getHeader("Last-Modified")
-      });
-    }
-    return false;
-  }
-  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);
-    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);
-  }
-  get status() {
-    return this.res.statusCode;
-  }
-  set status(statusCode) {
-    this.res.statusCode = statusCode;
-  }
-  resHasHandled() {
-    return this.res.writableEnded;
-  }
-  error(dig, e = "") {
-    this.logger.error(
-      `Web Server Error - ${dig}, error = %s, req.url = %s, req.headers = %o`,
-      e instanceof Error ? e.stack || e.message : e,
-      this.path,
-      headersWithoutCookie(this.headers)
-    );
-  }
-}
-export {
-  ModernServerContext
-};

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

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