@modern-js/server-core 2.48.3-alpha.0 → 2.48.4

package/dist/esm-node/base/adapters/node/polyfills/stream.js

@@ -1,126 +0,0 @@
-import { Stream } from "node:stream";
-async function writeReadableStreamToWritable(stream, writable) {
-  const reader = stream.getReader();
-  const flushable = writable;
-  try {
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) {
-        writable.end();
-        break;
-      }
-      writable.write(value);
-      if (typeof flushable.flush === "function") {
-        flushable.flush();
-      }
-    }
-  } catch (error) {
-    writable.destroy(error);
-    throw error;
-  }
-}
-async function writeAsyncIterableToWritable(iterable, writable) {
-  try {
-    for await (const chunk of iterable) {
-      writable.write(chunk);
-    }
-    writable.end();
-  } catch (error) {
-    writable.destroy(error);
-    throw error;
-  }
-}
-async function readableStreamToString(stream, encoding) {
-  const reader = stream.getReader();
-  const chunks = [];
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) {
-      break;
-    }
-    if (value) {
-      chunks.push(value);
-    }
-  }
-  return Buffer.concat(chunks).toString(encoding);
-}
-const createReadableStreamFromReadable = (source) => {
-  const pump = new StreamPump(source);
-  const stream = new ReadableStream(pump, pump);
-  return stream;
-};
-class StreamPump {
-  size(chunk) {
-    return (chunk === null || chunk === void 0 ? void 0 : chunk.byteLength) || 0;
-  }
-  start(controller) {
-    this.controller = controller;
-    this.stream.on("data", this.enqueue);
-    this.stream.once("error", this.error);
-    this.stream.once("end", this.close);
-    this.stream.once("close", this.close);
-  }
-  pull() {
-    this.resume();
-  }
-  cancel(reason) {
-    if (this.stream.destroy) {
-      this.stream.destroy(reason);
-    }
-    this.stream.off("data", this.enqueue);
-    this.stream.off("error", this.error);
-    this.stream.off("end", this.close);
-    this.stream.off("close", this.close);
-  }
-  enqueue(chunk) {
-    if (this.controller) {
-      try {
-        const bytes = chunk instanceof Uint8Array ? chunk : Buffer.from(chunk);
-        const available = (this.controller.desiredSize || 0) - bytes.byteLength;
-        this.controller.enqueue(bytes);
-        if (available <= 0) {
-          this.pause();
-        }
-      } catch (error) {
-        this.controller.error(new Error("Could not create Buffer, chunk must be of type string or an instance of Buffer, ArrayBuffer, or Array or an Array-like Object"));
-        this.cancel();
-      }
-    }
-  }
-  pause() {
-    if (this.stream.pause) {
-      this.stream.pause();
-    }
-  }
-  resume() {
-    if (this.stream.readable && this.stream.resume) {
-      this.stream.resume();
-    }
-  }
-  close() {
-    if (this.controller) {
-      this.controller.close();
-      delete this.controller;
-    }
-  }
-  error(error) {
-    if (this.controller) {
-      this.controller.error(error);
-      delete this.controller;
-    }
-  }
-  constructor(stream) {
-    this.highWaterMark = stream.readableHighWaterMark || new Stream.Readable().readableHighWaterMark;
-    this.accumalatedSize = 0;
-    this.stream = stream;
-    this.enqueue = this.enqueue.bind(this);
-    this.error = this.error.bind(this);
-    this.close = this.close.bind(this);
-  }
-}
-export {
-  createReadableStreamFromReadable,
-  readableStreamToString,
-  writeAsyncIterableToWritable,
-  writeReadableStreamToWritable
-};

package/dist/esm-node/base/constants.js

@@ -1,31 +0,0 @@
-const AGGRED_DIR = {
-  mock: "config/mock",
-  server: "server",
-  api: "api",
-  shared: "shared",
-  lambda: "lambda"
-};
-const REPLACE_REG = {
-  before: {
-    head: "<head[^>]*>",
-    body: "<body[^>]*>"
-  },
-  after: {
-    head: "</head>",
-    body: "</body>"
-  }
-};
-var ServerReportTimings;
-(function(ServerReportTimings2) {
-  ServerReportTimings2["SERVER_HANDLE_REQUEST"] = "server-handle-request";
-  ServerReportTimings2["SERVER_MIDDLEWARE"] = "server-middleware";
-  ServerReportTimings2["SERVER_HOOK_AFTER_RENDER"] = "server-hook-after-render";
-  ServerReportTimings2["SERVER_HOOK_AFTER_MATCH"] = "server-hook-after-match";
-})(ServerReportTimings || (ServerReportTimings = {}));
-const X_RENDER_CACHE = "x-render-cache";
-export {
-  AGGRED_DIR,
-  REPLACE_REG,
-  ServerReportTimings,
-  X_RENDER_CACHE
-};

package/dist/esm-node/base/index.js

@@ -1,14 +0,0 @@
-import { createErrorHtml } from "./utils";
-import { AGGRED_DIR } from "./constants";
-import { favionFallbackMiddleware, injectReporter, injectLogger, getRenderHandler, bindRenderHandler } from "./middlewares";
-import { createServerBase } from "./serverBase";
-export {
-  AGGRED_DIR,
-  bindRenderHandler,
-  createErrorHtml,
-  createServerBase,
-  favionFallbackMiddleware,
-  getRenderHandler,
-  injectLogger,
-  injectReporter
-};

package/dist/esm-node/base/middlewares/customServer/base.js

@@ -1,87 +0,0 @@
-import { getCookie } from "hono/cookie";
-import { getHost } from "../../utils";
-function createBaseHookContext(c, logger, metrics) {
-  return {
-    request: new BaseHookRequest(c),
-    response: new BaseHookResponse(c),
-    logger,
-    metrics
-  };
-}
-class BaseHookRequest {
-  get url() {
-    return this.req.url;
-  }
-  get host() {
-    return getHost(this.req.raw);
-  }
-  get pathname() {
-    return this.req.path;
-  }
-  get query() {
-    return this.req.query();
-  }
-  get headers() {
-    return this.req.header();
-  }
-  get cookies() {
-    return {
-      // FIXME: ModernRequest Type Error
-      get: (key) => {
-        return getCookie(this.c, key);
-      }
-    };
-  }
-  get cookie() {
-    return this.req.header("cookie");
-  }
-  constructor(c) {
-    this.c = c;
-    this.req = c.req;
-  }
-}
-class BaseHookResponse {
-  get(key) {
-    return this.c.res.headers.get(key);
-  }
-  set(key, value) {
-    if ([
-      "set-cookie",
-      "Set-Cookie"
-    ].includes(key)) {
-      this.c.header(key, value.toString(), {
-        append: true
-      });
-    } else {
-      this.c.header(key, value.toString());
-    }
-  }
-  status(code) {
-    this.c.status(code);
-  }
-  get cookies() {
-    const setCookie = (key, value) => {
-      this.c.header("set-cookie", `${key}=${value}`, {
-        append: true
-      });
-    };
-    const clearCookie = () => {
-      this.c.header("set-cookie", void 0);
-    };
-    return {
-      set: setCookie,
-      clear: clearCookie
-    };
-  }
-  raw(body, options) {
-    this.c.res = this.c.newResponse(body, options);
-    this.private_overrided = true;
-  }
-  constructor(c) {
-    this.private_overrided = false;
-    this.c = c;
-  }
-}
-export {
-  createBaseHookContext
-};

package/dist/esm-node/base/middlewares/customServer/context.js

@@ -1,51 +0,0 @@
-import { RouterAPI } from "./routerApi";
-import { TemplateApi } from "./template";
-import { createBaseHookContext } from "./base";
-function createAfterMatchCtx(c, entryName, logger, metrics) {
-  const baseContext = createBaseHookContext(c, logger, metrics);
-  return {
-    ...baseContext,
-    router: new RouterAPI(entryName)
-  };
-}
-async function createAfterRenderCtx(c, logger, metrics) {
-  const baseContext = createBaseHookContext(c, logger, metrics);
-  const resBody = await c.res.text();
-  return {
-    ...baseContext,
-    template: new TemplateApi(resBody)
-  };
-}
-function createCustomMiddlewaresCtx(c, logger, metrics) {
-  var _c_env_node, _c_env_node1;
-  const baseContext = createBaseHookContext(c, logger, metrics);
-  const reporter = c.get("reporter");
-  return {
-    ...baseContext,
-    reporter,
-    response: {
-      ...baseContext.response,
-      locals: {}
-    },
-    source: {
-      req: (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req,
-      res: (_c_env_node1 = c.env.node) === null || _c_env_node1 === void 0 ? void 0 : _c_env_node1.res
-    }
-  };
-}
-function createAfterStreamingRenderContext(c, logger, route, metrics) {
-  const baseContext = createBaseHookContext(c, logger, metrics);
-  return (chunk) => {
-    return {
-      ...baseContext,
-      route,
-      chunk
-    };
-  };
-}
-export {
-  createAfterMatchCtx,
-  createAfterRenderCtx,
-  createAfterStreamingRenderContext,
-  createCustomMiddlewaresCtx
-};

package/dist/esm-node/base/middlewares/customServer/index.js

@@ -1,106 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import { transformResponse } from "../../utils";
-import { ServerReportTimings } from "../../constants";
-import { createAfterMatchCtx, createAfterRenderCtx, createCustomMiddlewaresCtx, createAfterStreamingRenderContext } from "./context";
-const noop = () => {
-};
-const isHtmlResponse = (response) => {
-  const contentType = response.headers.get("content-type");
-  return contentType === null || contentType === void 0 ? void 0 : contentType.includes("text/html");
-};
-class CustomServer {
-  getHookMiddleware(entryName, routes) {
-    return async (c, next) => {
-      const routeInfo = routes.find((route) => route.entryName === entryName);
-      const logger = c.get("logger");
-      const reporter = c.get("reporter");
-      const metrics = c.get("metrics");
-      const afterMatchCtx = createAfterMatchCtx(c, entryName, logger, metrics);
-      const getCost = time();
-      await this.runner.afterMatch(afterMatchCtx, {
-        onLast: noop
-      });
-      const cost = getCost();
-      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_MATCH, cost));
-      const {
-        // current,
-        url,
-        status
-      } = afterMatchCtx.router;
-      if (url) {
-        return c.redirect(url, status);
-      }
-      const { current } = afterMatchCtx.router;
-      if (current !== entryName) {
-        const rewriteRoute = routes.find((route) => route.entryName === current);
-        if (rewriteRoute) {
-          return this.serverBase.request(rewriteRoute.urlPath);
-        }
-      }
-      if (c.finalized) {
-        return void 0;
-      }
-      await next();
-      if (c.finalized && (!c.res.body || !isHtmlResponse(c.res))) {
-        return void 0;
-      }
-      if (routeInfo.isStream) {
-        const afterStreamingRenderContext = createAfterStreamingRenderContext(c, logger, routeInfo, metrics);
-        c.res = transformResponse(c.res, (chunk) => {
-          const context = afterStreamingRenderContext(chunk);
-          return this.runner.afterStreamingRender(context, {
-            onLast: ({ chunk: chunk2 }) => chunk2
-          });
-        });
-      } else {
-        const afterRenderCtx = await createAfterRenderCtx(c, logger, metrics);
-        const getCost2 = time();
-        await this.runner.afterRender(afterRenderCtx, {
-          onLast: noop
-        });
-        const cost2 = getCost2();
-        cost2 && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_HOOK_AFTER_RENDER, cost2));
-        if (afterRenderCtx.response.private_overrided) {
-          return void 0;
-        }
-        const newBody = afterRenderCtx.template.get();
-        c.res = c.body(newBody);
-      }
-    };
-  }
-  getServerMiddleware() {
-    return async (c, next) => {
-      const serverMiddleware = await this.serverMiddlewarePromise;
-      if (!serverMiddleware) {
-        return next();
-      }
-      const logger = c.get("logger");
-      const reporter = c.get("reporter");
-      const metrics = c.get("metrics");
-      const customMiddlewareCtx = createCustomMiddlewaresCtx(c, logger, metrics);
-      const getCost = time();
-      await serverMiddleware(customMiddlewareCtx);
-      const cost = getCost();
-      cost && (reporter === null || reporter === void 0 ? void 0 : reporter.reportTiming(ServerReportTimings.SERVER_MIDDLEWARE, cost));
-      if (!c.finalized) {
-        return next();
-      }
-    };
-  }
-  constructor(runner, serverBase, pwd) {
-    this.runner = runner;
-    this.serverBase = serverBase;
-    const webExtension = [];
-    this.serverMiddlewarePromise = runner.prepareWebServer({
-      pwd,
-      config: {
-        middleware: webExtension
-      }
-    }, {
-      onLast: () => null
-    });
-  }
-}
-export {
-  CustomServer
-};

package/dist/esm-node/base/middlewares/customServer/routerApi.js

@@ -1,20 +0,0 @@
-class RouterAPI {
-  redirect(url, status = 302) {
-    this.url = url;
-    this.status = status;
-  }
-  rewrite(entryName) {
-    this.current = entryName;
-  }
-  use(entryName) {
-    this.rewrite(entryName);
-  }
-  constructor(entryName) {
-    this.current = entryName;
-    this.status = 200;
-    this.url = "";
-  }
-}
-export {
-  RouterAPI
-};

package/dist/esm-node/base/middlewares/customServer/template.js

@@ -1,34 +0,0 @@
-import { REPLACE_REG } from "../../constants";
-class TemplateApi {
-  set(content) {
-    this.body = content;
-  }
-  get() {
-    return this.body;
-  }
-  prependHead(fragment) {
-    const { head } = REPLACE_REG.before;
-    this.replaceBody(new RegExp(head), (beforeHead) => `${beforeHead}${fragment}`);
-  }
-  appendHead(fragment) {
-    const { head } = REPLACE_REG.after;
-    this.replaceBody(head, () => `${fragment}${head}`);
-  }
-  prependBody(fragment) {
-    const { body } = REPLACE_REG.before;
-    this.replaceBody(new RegExp(body), (beforeBody) => `${beforeBody}${fragment}`);
-  }
-  appendBody(fragment) {
-    const { body } = REPLACE_REG.after;
-    this.replaceBody(body, () => `${fragment}${body}`);
-  }
-  replaceBody(searchValue, replaceCb) {
-    this.body = this.body.replace(searchValue, replaceCb);
-  }
-  constructor(body) {
-    this.body = body;
-  }
-}
-export {
-  TemplateApi
-};

package/dist/esm-node/base/middlewares/faviconFallback.js

@@ -1,10 +0,0 @@
-const favionFallbackMiddleware = async (c, next) => {
-  if (c.req.path === "/favicon.ico") {
-    return c.body(null, 204);
-  } else {
-    return next();
-  }
-};
-export {
-  favionFallbackMiddleware
-};

package/dist/esm-node/base/middlewares/index.js

@@ -1,3 +0,0 @@
-export * from "./faviconFallback";
-export * from "./monitor";
-export * from "./renderHandler";

package/dist/esm-node/base/middlewares/monitor.js

@@ -1,63 +0,0 @@
-import { time } from "@modern-js/runtime-utils/time";
-import { ServerReportTimings } from "../constants";
-const defaultReporter = {
-  init() {
-  },
-  reportError() {
-  },
-  reportTiming() {
-  },
-  reportInfo() {
-  },
-  reportWarn() {
-  }
-};
-function injectReporter() {
-  return async (c, next) => {
-    const reporter = c.get("reporter");
-    if (!reporter) {
-      c.set("reporter", defaultReporter);
-    }
-    await next();
-  };
-}
-function initReporter(entryName) {
-  return async (c, next) => {
-    const reporter = c.get("reporter");
-    if (!reporter) {
-      await next();
-      return;
-    }
-    await reporter.init({
-      entryName
-    });
-    const getCost = time();
-    await next();
-    const cost = getCost();
-    reporter.reportTiming(ServerReportTimings.SERVER_HANDLE_REQUEST, cost);
-  };
-}
-function injectLogger(inputLogger) {
-  return async (c, next) => {
-    const logger = c.get("logger");
-    if (!logger && inputLogger) {
-      c.set("logger", inputLogger);
-    }
-    await next();
-  };
-}
-function injectMetrics(inputMetrics) {
-  return async (c, next) => {
-    const metrics = c.get("metrics");
-    if (!metrics) {
-      c.set("metrics", inputMetrics);
-    }
-    await next();
-  };
-}
-export {
-  initReporter,
-  injectLogger,
-  injectMetrics,
-  injectReporter
-};

package/dist/esm-node/base/middlewares/renderHandler/dataHandler.js

@@ -1,22 +0,0 @@
-import { MAIN_ENTRY_NAME } from "@modern-js/utils/universal/constants";
-const dataHandler = async (request, { routeInfo, serverRoutes, reporter, logger, serverManifest }) => {
-  var _serverManifest_loaderBundles;
-  const serverLoaderModule = serverManifest === null || serverManifest === void 0 ? void 0 : (_serverManifest_loaderBundles = serverManifest.loaderBundles) === null || _serverManifest_loaderBundles === void 0 ? void 0 : _serverManifest_loaderBundles[routeInfo.entryName || MAIN_ENTRY_NAME];
-  if (!serverLoaderModule) {
-    return;
-  }
-  const { routes, handleRequest } = serverLoaderModule;
-  const response = await handleRequest({
-    request,
-    serverRoutes,
-    context: {
-      logger,
-      reporter
-    },
-    routes
-  });
-  return response;
-};
-export {
-  dataHandler
-};

package/dist/esm-node/base/middlewares/renderHandler/index.js

@@ -1,69 +0,0 @@
-import { checkIsProd, sortRoutes, getRuntimeEnv } from "../../utils";
-import { initReporter } from "../monitor";
-import { CustomServer } from "../customServer";
-import { createRender } from "./render";
-function createRenderHandler(render) {
-  return async (c, _) => {
-    var _c_env_node;
-    const logger = c.get("logger");
-    const reporter = c.get("reporter");
-    const templates = c.get("templates") || {};
-    const serverManifest = c.get("serverManifest") || {};
-    const request = c.req.raw;
-    const nodeReq = (_c_env_node = c.env.node) === null || _c_env_node === void 0 ? void 0 : _c_env_node.req;
-    const res = await render(request, {
-      logger,
-      nodeReq,
-      reporter,
-      templates,
-      serverManifest
-    });
-    return res;
-  };
-}
-async function getRenderHandler(options) {
-  const { routes, pwd, config } = options;
-  if (routes && routes.length > 0) {
-    var _config_server, _options_config_security;
-    const ssrConfig = (_config_server = config.server) === null || _config_server === void 0 ? void 0 : _config_server.ssr;
-    const forceCSR = typeof ssrConfig === "object" ? ssrConfig.forceCSR : false;
-    const render = createRender({
-      routes,
-      pwd,
-      staticGenerate: options.staticGenerate,
-      metaName: options.metaName || "modern-js",
-      forceCSR,
-      nonce: (_options_config_security = options.config.security) === null || _options_config_security === void 0 ? void 0 : _options_config_security.nonce
-    });
-    return render;
-  }
-  return null;
-}
-async function bindRenderHandler(server, options) {
-  const { routes, pwd } = options;
-  const { runner } = server;
-  if (routes && routes.length > 0) {
-    const customServer = new CustomServer(runner, server, pwd);
-    if (getRuntimeEnv() === "node") {
-      const cacheModuleName = "./ssrCache";
-      const { ssrCache } = await import(cacheModuleName);
-      await ssrCache.loadCacheMod(checkIsProd() ? pwd : void 0);
-    }
-    const pageRoutes = routes.filter((route) => !route.isApi).sort(sortRoutes);
-    for (const route of pageRoutes) {
-      const { urlPath: originUrlPath, entryName } = route;
-      const urlPath = originUrlPath.endsWith("/") ? `${originUrlPath}*` : `${originUrlPath}/*`;
-      const customServerHookMiddleware = customServer.getHookMiddleware(entryName || "main", routes);
-      server.use(urlPath, initReporter(entryName));
-      server.use(urlPath, customServerHookMiddleware);
-      const customServerMiddleware = customServer.getServerMiddleware();
-      server.use(urlPath, customServerMiddleware);
-    }
-    const render = await getRenderHandler(options);
-    render && server.all("*", createRenderHandler(render));
-  }
-}
-export {
-  bindRenderHandler,
-  getRenderHandler
-};