@modern-js/prod-server 2.46.1 → 2.47.1-alpha.0

package/dist/esm-node/libs/preload/parseLinks.js

@@ -1,90 +0,0 @@
-import path from "path";
-import { NESTED_ROUTE_SPEC_FILE, ROUTE_MANIFEST_FILE, ROUTE_SPEC_FILE, fs } from "@modern-js/utils";
-import { parse as htmlParse } from "node-html-parser";
-import { matchRoutes } from "@modern-js/runtime-utils/remix-router";
-import { matchEntry } from "@modern-js/runtime-utils/node";
-async function parseLinks({ pathname, distDir, template }) {
-  const links = await parseLinksFromRoutes(pathname, distDir);
-  return links.concat(parseLinksFromHtml(template));
-}
-function parseLinksFromHtml(html) {
-  const root = htmlParse(html);
-  const scripts = root.querySelectorAll("script").filter((elem) => Boolean(elem.getAttribute("src")));
-  const css = root.querySelectorAll("link").filter((elem) => {
-    const href = elem.getAttribute("href");
-    const rel = elem.getAttribute("rel");
-    return href && rel === "stylesheet";
-  });
-  const images = root.querySelectorAll("img").filter((elem) => Boolean(elem.getAttribute("src")));
-  return scripts.map((elem) => {
-    const src = elem.getAttribute("src");
-    return {
-      uri: src,
-      as: "script"
-    };
-  }).concat(css.map((elem) => {
-    const href = elem.getAttribute("href");
-    return {
-      uri: href,
-      as: "style"
-    };
-  })).concat(images.map((elem) => {
-    const src = elem.getAttribute("src");
-    return {
-      uri: src,
-      as: "image"
-    };
-  }));
-}
-async function parseLinksFromRoutes(pathname, distDir) {
-  const noopLinks = [];
-  const nestedRoutesSpec = path.join(distDir, NESTED_ROUTE_SPEC_FILE);
-  const routesJsonPath = path.join(distDir, ROUTE_SPEC_FILE);
-  const routeManifestPath = path.join(distDir, ROUTE_MANIFEST_FILE);
-  if (!fs.existsSync(nestedRoutesSpec) || !fs.existsSync(routesJsonPath) || !fs.existsSync(routeManifestPath)) {
-    return noopLinks;
-  }
-  const routesJson = await import(routesJsonPath);
-  const serverRoutes = routesJson.routes;
-  const entry = matchEntry(pathname, serverRoutes);
-  if (entry) {
-    var _routeAssets_entryName, _assets_filter, _assets_filter1;
-    const routes = await import(nestedRoutesSpec);
-    const { entryName } = entry;
-    if (!entryName) {
-      return noopLinks;
-    }
-    const entryRoutes = routes[entryName];
-    if (!entryRoutes) {
-      return noopLinks;
-    }
-    const routesManifest = await import(routeManifestPath);
-    const { routeAssets } = routesManifest;
-    const matches = matchRoutes(entryRoutes, pathname, entry.urlPath);
-    const entryAssets = (_routeAssets_entryName = routeAssets[entryName]) === null || _routeAssets_entryName === void 0 ? void 0 : _routeAssets_entryName.assets;
-    const assets = matches === null || matches === void 0 ? void 0 : matches.reduce((acc, match) => {
-      const routeId = match.route.id;
-      if (routeId) {
-        const matchedManifest = routeAssets[routeId];
-        const assets2 = matchedManifest === null || matchedManifest === void 0 ? void 0 : matchedManifest.assets;
-        if (Array.isArray(assets2)) {
-          acc.push(...assets2);
-        }
-      }
-      return acc;
-    }, []).concat(entryAssets || []);
-    const cssLinks = assets === null || assets === void 0 ? void 0 : (_assets_filter = assets.filter((asset) => asset.endsWith(".css"))) === null || _assets_filter === void 0 ? void 0 : _assets_filter.map((uri) => ({
-      uri,
-      as: "style"
-    }));
-    const scriptLinks = assets === null || assets === void 0 ? void 0 : (_assets_filter1 = assets.filter((asset) => asset.endsWith(".js"))) === null || _assets_filter1 === void 0 ? void 0 : _assets_filter1.map((uri) => ({
-      uri,
-      as: "script"
-    }));
-    return (cssLinks || []).concat(scriptLinks || []);
-  }
-  return noopLinks;
-}
-export {
-  parseLinks
-};

package/dist/esm-node/libs/preload/shouldFlushServerHeader.js

@@ -1,27 +0,0 @@
-function transformToRegExp(input) {
-  if (typeof input === "string") {
-    return new RegExp(input);
-  }
-  return input;
-}
-function shouldFlushServerHeader(serverConf, userAgent, disablePreload) {
-  const { ssr: ssrConf } = serverConf || {};
-  if (disablePreload) {
-    return false;
-  }
-  if (typeof ssrConf === "object" && ssrConf.preload) {
-    if (typeof ssrConf.preload === "object") {
-      const { userAgentFilter } = ssrConf.preload;
-      if (userAgentFilter && userAgent) {
-        return !transformToRegExp(userAgentFilter).test(userAgent);
-      }
-      return true;
-    }
-    return true;
-  }
-  return false;
-}
-export {
-  shouldFlushServerHeader,
-  transformToRegExp
-};

package/dist/esm-node/libs/preload/transformLinks2String.js

@@ -1,126 +0,0 @@
-import { transformToRegExp } from "./shouldFlushServerHeader";
-function transformLinks2String(links, preload) {
-  if (typeof preload === "boolean") {
-    return transformLinkToString(dedup(links));
-  }
-  const { include, exclude, attributes } = preload;
-  const resolveLinks = transformLinkToString(addAttributes(dedup(removeExclude(addInclude(links, include), exclude)), attributes));
-  return resolveLinks;
-}
-function addInclude(links, include) {
-  const images = [
-    "gif",
-    "jpg",
-    "jpeg",
-    "png",
-    "webp",
-    "bmp",
-    "tiff",
-    "anpg",
-    "ico"
-  ];
-  const videos = [
-    "mp4",
-    "webm",
-    "ogm",
-    "ogv",
-    "ogg"
-  ];
-  const fonts = [
-    "woff",
-    "woff2",
-    "eot",
-    "ttf",
-    "otf"
-  ];
-  const includes = (include === null || include === void 0 ? void 0 : include.map((item) => {
-    if (typeof item === "string") {
-      const type = (() => {
-        if (item.endsWith(".js")) {
-          return "script";
-        }
-        if (item.endsWith(".css")) {
-          return "style";
-        }
-        if (images.some((image) => item.endsWith(`.${image}`))) {
-          return "image";
-        }
-        if (videos.some((video) => item.endsWith(`.${video}`))) {
-          return "video";
-        }
-        if (fonts.some((font) => item.endsWith(`.${font}`))) {
-          return "font";
-        }
-      })();
-      return {
-        uri: item,
-        as: type
-      };
-    }
-    return {
-      uri: item.url,
-      as: item.as,
-      rel: item.rel
-    };
-  })) || [];
-  return links.concat(includes);
-}
-function removeExclude(links, exclude) {
-  return exclude ? links.filter(({ uri }) => !transformToRegExp(exclude).test(uri)) : links;
-}
-function addAttributes(links, attributes) {
-  const parseAttributes = (_attributes) => {
-    return Object.entries(_attributes || {}).reduce((results, [key, value]) => {
-      if (typeof value === "boolean") {
-        value && results.push(`; ${key}`);
-        return results;
-      }
-      results.push(`; ${key}=${value}`);
-      return results;
-    }, []).join("");
-  };
-  return links.map((link) => {
-    const { as } = link;
-    if (as) {
-      const attributesStr = (() => {
-        const { style, script, image, font } = attributes || {};
-        switch (as) {
-          case "script":
-            return parseAttributes(script);
-          case "style":
-            return parseAttributes(style);
-          case "image":
-            return parseAttributes(image);
-          case "font":
-            return parseAttributes(font);
-          default:
-            return "";
-        }
-      })();
-      return {
-        ...link,
-        rest: attributesStr
-      };
-    }
-    return link;
-  });
-}
-function dedup(links) {
-  const set = /* @__PURE__ */ new Set();
-  return links.filter(({ uri }) => {
-    if (set.has(uri)) {
-      return false;
-    }
-    set.add(uri);
-    return true;
-  });
-}
-function transformLinkToString(links) {
-  return links.map(({ uri, as, rel: originalRel, rest }) => {
-    const rel = originalRel || "preload";
-    return as ? `<${uri}>; rel=${rel}; as=${as}${rest || ""}` : `<${uri}>; rel=${rel}${rest || ""}`;
-  }).join(", ");
-}
-export {
-  transformLinks2String
-};

package/dist/esm-node/libs/proxy.js

@@ -1,74 +0,0 @@
-import { HttpProxyMiddleware } from "http-proxy-middleware/dist/http-proxy-middleware";
-import { debug } from "../utils";
-function formatProxyOptions(proxyOptions) {
-  const ret = [];
-  if (Array.isArray(proxyOptions)) {
-    ret.push(...proxyOptions);
-  } else if ("target" in proxyOptions) {
-    ret.push(proxyOptions);
-  } else {
-    for (const [context, options] of Object.entries(proxyOptions)) {
-      const opts = {
-        context,
-        changeOrigin: true,
-        logLevel: "warn"
-      };
-      if (typeof options === "string") {
-        opts.target = options;
-      } else {
-        Object.assign(opts, options);
-      }
-      ret.push(opts);
-    }
-  }
-  const handleError = (err, _req, _res, _target) => {
-    console.error(err);
-  };
-  for (const opts of ret) {
-    var _opts;
-    var _onError;
-    (_onError = (_opts = opts).onError) !== null && _onError !== void 0 ? _onError : _opts.onError = handleError;
-  }
-  return ret;
-}
-const createProxyHandler = (proxyOptions) => {
-  debug("createProxyHandler", proxyOptions);
-  const formattedOptionsList = formatProxyOptions(proxyOptions);
-  const proxies = [];
-  const handlers = [];
-  for (const opts of formattedOptionsList) {
-    const proxy = new HttpProxyMiddleware(opts.context, opts);
-    const handler = async (ctx, next) => {
-      const { req, res } = ctx;
-      const bypassUrl = typeof opts.bypass === "function" ? opts.bypass(req, res, opts) : null;
-      if (typeof bypassUrl === "boolean") {
-        ctx.status = 404;
-        next();
-      } else if (typeof bypassUrl === "string") {
-        ctx.url = bypassUrl;
-        next();
-      } else {
-        proxy.middleware(req, res, next);
-      }
-    };
-    proxies.push(proxy);
-    handlers.push(handler);
-  }
-  const handleUpgrade = (server) => {
-    for (const proxy of proxies) {
-      const raw = proxy;
-      if (raw.proxyOptions.ws === true && !raw.wsInternalSubscribed) {
-        server.on("upgrade", raw.handleUpgrade);
-        raw.wsInternalSubscribed = true;
-      }
-    }
-  };
-  return {
-    handlers,
-    handleUpgrade
-  };
-};
-export {
-  createProxyHandler,
-  formatProxyOptions
-};

package/dist/esm-node/libs/render/index.js

@@ -1,63 +0,0 @@
-import path from "path";
-import { cutNameByHyphen, mime } from "@modern-js/utils";
-import { fileReader } from "@modern-js/runtime-utils/fileReader";
-import { ERROR_DIGEST } from "../../constants";
-import { shouldFlushServerHeader } from "../preload/shouldFlushServerHeader";
-import { handleDirectory } from "./static";
-import * as ssr from "./ssr";
-import { injectServerData } from "./utils";
-const calcFallback = (metaName) => `x-${cutNameByHyphen(metaName)}-ssr-fallback`;
-const createRenderHandler = ({ distDir, staticGenerate, conf, forceCSR, nonce, ssrRender, metaName = "modern-js" }) => async function render({ ctx, route, runner }) {
-  if (ctx.resHasHandled()) {
-    return null;
-  }
-  const { entryPath, urlPath } = route;
-  const entry = path.join(distDir, entryPath);
-  if (!route.isSPA) {
-    const result = await handleDirectory(ctx, entry, urlPath);
-    return result;
-  }
-  const templatePath = entry;
-  const content = await fileReader.readFile(templatePath);
-  if (!content) {
-    return null;
-  }
-  const useCSR = forceCSR && (ctx.query.csr || ctx.headers[calcFallback(metaName)]);
-  if (route.isSSR && !useCSR) {
-    try {
-      const userAgent = ctx.getReqHeader("User-Agent");
-      const disablePreload = Boolean(ctx.headers[`x-${cutNameByHyphen(metaName)}-disable-preload`]);
-      if (shouldFlushServerHeader(conf.server, userAgent, disablePreload)) {
-        const { flushServerHeader } = await import("../preload");
-        flushServerHeader({
-          serverConf: conf.server,
-          ctx,
-          distDir,
-          template: content.toString(),
-          headers: {
-            "Content-Type": mime.contentType(path.extname(templatePath))
-          }
-        });
-      }
-      const ssrRenderOptions = {
-        distDir,
-        route,
-        template: content.toString(),
-        staticGenerate,
-        nonce
-      };
-      const result = await (ssrRender ? ssrRender(ctx, ssrRenderOptions, runner) : ssr.render(ctx, ssrRenderOptions, runner));
-      return result;
-    } catch (err) {
-      ctx.error(ERROR_DIGEST.ERENDER, err.stack || err.message);
-      ctx.res.set(calcFallback(metaName), "1");
-    }
-  }
-  return {
-    content: route.entryName ? injectServerData(content.toString(), ctx) : content,
-    contentType: mime.contentType(path.extname(templatePath))
-  };
-};
-export {
-  createRenderHandler
-};

package/dist/esm-node/libs/render/measure.js

@@ -1,49 +0,0 @@
-import { headersWithoutCookie } from "../../utils";
-const createMetrics = (context, metrics) => {
-  const { entryName: entry, request } = context;
-  const { pathname = "" } = request || {};
-  const emitTimer = (name, cost, tags = {}) => {
-    metrics.emitTimer(name, cost, void 0, {
-      ...tags,
-      pathname,
-      entry
-    });
-  };
-  const emitCounter = (name, counter, tags = {}) => {
-    metrics.emitCounter(name, counter, void 0, {
-      ...tags,
-      pathname,
-      entry
-    });
-  };
-  return {
-    emitTimer,
-    emitCounter
-  };
-};
-const createLogger = (serverContext, logger) => {
-  const request = serverContext.request || {};
-  const { headers = {}, pathname = "" } = request;
-  const debug = (message, ...args) => {
-    logger.debug(`SSR Debug - ${message}, req.url = %s`, ...args, pathname);
-  };
-  const info = (message, ...args) => {
-    logger.info(`SSR Info - ${message}, req.url = %s`, ...args, pathname);
-  };
-  const error = (message, e) => {
-    if (!e) {
-      e = message;
-      message = "";
-    }
-    logger.error(`SSR Error - ${message}, error = %s, req.url = %s, req.headers = %o`, e instanceof Error ? e.stack || e.message : e, pathname, headersWithoutCookie(headers));
-  };
-  return {
-    error,
-    info,
-    debug
-  };
-};
-export {
-  createLogger,
-  createMetrics
-};

package/dist/esm-node/libs/render/ssr.js

@@ -1,92 +0,0 @@
-import path from "path";
-import { fs, mime, LOADABLE_STATS_FILE, ROUTE_MANIFEST_FILE, SERVER_RENDER_FUNCTION_NAME } from "@modern-js/utils";
-import * as isbot from "isbot";
-import { createAfterStreamingRenderContext } from "../hook-api";
-import { afterRenderInjectableStream } from "../hook-api/afterRenderForStream";
-import { createLogger, createMetrics } from "./measure";
-import { injectServerDataStream, injectServerData } from "./utils";
-import { ssrCache } from "./ssrCache";
-const render = async (ctx, renderOptions, runner) => {
-  var _ctx_res;
-  const { distDir, route, template, staticGenerate, enableUnsafeCtx = false, nonce } = renderOptions;
-  const { urlPath, bundle, entryName } = route;
-  const bundleJS = path.join(distDir, bundle);
-  const loadableUri = path.join(distDir, LOADABLE_STATS_FILE);
-  const loadableStats = fs.existsSync(loadableUri) ? require(loadableUri) : "";
-  const routesManifestUri = path.join(distDir, ROUTE_MANIFEST_FILE);
-  const routeManifest = fs.existsSync(routesManifestUri) ? require(routesManifestUri) : void 0;
-  const isSpider = isbot.default(ctx.headers["user-agent"] || null);
-  const context = {
-    request: {
-      baseUrl: urlPath,
-      params: ctx.params,
-      pathname: ctx.path,
-      host: ctx.host,
-      query: ctx.query,
-      url: ctx.href,
-      headers: ctx.headers
-    },
-    response: {
-      setHeader: (key, value) => {
-        return ctx.res.setHeader(key, value);
-      },
-      status: (code) => {
-        ctx.res.statusCode = code;
-      },
-      locals: ((_ctx_res = ctx.res) === null || _ctx_res === void 0 ? void 0 : _ctx_res.locals) || {}
-    },
-    redirection: {},
-    template,
-    loadableStats,
-    routeManifest,
-    entryName,
-    staticGenerate,
-    logger: void 0,
-    metrics: void 0,
-    reporter: ctx.reporter,
-    serverTiming: ctx.serverTiming,
-    req: ctx.req,
-    res: ctx.res,
-    enableUnsafeCtx,
-    isSpider,
-    nonce
-  };
-  context.logger = createLogger(context, ctx.logger);
-  context.metrics = createMetrics(context, ctx.metrics);
-  runner.extendSSRContext(context);
-  const bundleJSContent = await Promise.resolve(require(bundleJS));
-  const serverRender = bundleJSContent[SERVER_RENDER_FUNCTION_NAME];
-  const content = await ssrCache(ctx.req, serverRender, context);
-  const { url, status = 302 } = context.redirection;
-  if (url) {
-    return {
-      content: url,
-      contentType: "",
-      statusCode: status,
-      redirect: true
-    };
-  }
-  if (typeof content === "string") {
-    return {
-      content: injectServerData(content, ctx),
-      contentType: mime.contentType("html")
-    };
-  } else {
-    let contentStream = injectServerDataStream(content, ctx);
-    const afterStreamingRenderContext = createAfterStreamingRenderContext(ctx, route);
-    contentStream = contentStream.pipe(afterRenderInjectableStream((chunk) => {
-      const context2 = afterStreamingRenderContext(chunk);
-      return runner.afterStreamingRender(context2, {
-        onLast: ({ chunk: chunk2 }) => chunk2
-      });
-    }));
-    return {
-      content: "",
-      contentStream,
-      contentType: mime.contentType("html")
-    };
-  }
-};
-export {
-  render
-};

package/dist/esm-node/libs/render/ssrCache/cacheMod.js

@@ -1,22 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import path from "path";
-import { SERVER_DIR, requireExistModule } from "@modern-js/utils";
-const CACHE_FILENAME = "cache";
-class ServerCacheMod {
-  loadServerCacheMod(pwd = process.cwd()) {
-    const serverCacheFilepath = path.resolve(pwd, SERVER_DIR, CACHE_FILENAME);
-    const mod = requireExistModule(serverCacheFilepath, {
-      interop: false
-    });
-    this.customContainer = mod === null || mod === void 0 ? void 0 : mod.customContainer;
-    this.cacheOption = mod === null || mod === void 0 ? void 0 : mod.cacheOption;
-  }
-  constructor() {
-    _define_property(this, "customContainer", void 0);
-    _define_property(this, "cacheOption", void 0);
-  }
-}
-const cacheMod = new ServerCacheMod();
-export {
-  cacheMod
-};

package/dist/esm-node/libs/render/ssrCache/index.js

@@ -1,57 +0,0 @@
-import { Transform } from "stream";
-import { createMemoryStorage } from "@modern-js/runtime-utils/storer";
-import { cacheMod } from "./cacheMod";
-import { CacheManager } from "./manager";
-const cacheStorage = createMemoryStorage("__ssr__cache");
-async function ssrCache(req, render, ssrContext) {
-  const { customContainer, cacheOption } = cacheMod;
-  const cacheControl = await matchCacheControl(req, cacheOption);
-  const cacheManager = new CacheManager(customContainer ? customContainer : cacheStorage);
-  if (cacheControl) {
-    return cacheManager.getCacheResult(req, cacheControl, render, ssrContext);
-  } else {
-    const renderResult = await render(ssrContext);
-    if (typeof renderResult === "string") {
-      return renderResult;
-    } else {
-      const stream = new Transform({
-        write(chunk, _, callback) {
-          this.push(chunk);
-          callback();
-        }
-      });
-      return renderResult(stream);
-    }
-  }
-}
-async function matchCacheControl(req, cacheOption) {
-  if (!cacheOption) {
-    return void 0;
-  } else if (isCacheControl(cacheOption)) {
-    return cacheOption;
-  } else if (isCacheOptionProvider(cacheOption)) {
-    return cacheOption(req);
-  } else {
-    const url = req.url;
-    const options = Object.entries(cacheOption);
-    for (const [key, option] of options) {
-      if (key === "*" || new RegExp(key).test(url)) {
-        if (typeof option === "function") {
-          return option(req);
-        } else {
-          return option;
-        }
-      }
-    }
-    return void 0;
-  }
-  function isCacheOptionProvider(option) {
-    return typeof option === "function";
-  }
-  function isCacheControl(option) {
-    return typeof option === "object" && option !== null && "maxAge" in option;
-  }
-}
-export {
-  ssrCache
-};

package/dist/esm-node/libs/render/ssrCache/manager.js

@@ -1,80 +0,0 @@
-import { _ as _define_property } from "@swc/helpers/_/_define_property";
-import { Transform } from "stream";
-class CacheManager {
-  async getCacheResult(req, cacheControl, render, ssrContext) {
-    const key = this.computedKey(req, cacheControl);
-    const value = await this.container.get(key);
-    const { maxAge, staleWhileRevalidate } = cacheControl;
-    const ttl = maxAge + staleWhileRevalidate;
-    if (value) {
-      const cache = JSON.parse(value);
-      const interval = Date.now() - cache.cursor;
-      if (interval <= maxAge) {
-        return cache.val;
-      } else if (interval <= staleWhileRevalidate + maxAge) {
-        this.processCache(key, render, ssrContext, ttl);
-        return cache.val;
-      } else {
-        return this.processCache(key, render, ssrContext, ttl);
-      }
-    } else {
-      return this.processCache(key, render, ssrContext, ttl);
-    }
-  }
-  async processCache(key, render, ssrContext, ttl) {
-    const renderResult = await render(ssrContext);
-    if (typeof renderResult === "string") {
-      const current = Date.now();
-      const cache = {
-        val: renderResult,
-        cursor: current
-      };
-      await this.container.set(key, JSON.stringify(cache), {
-        ttl
-      });
-      return renderResult;
-    } else {
-      let html;
-      const stream = new Transform({
-        write(chunk, _, callback) {
-          html += chunk.toString();
-          this.push(chunk);
-          callback();
-        }
-      });
-      stream.on("close", () => {
-        const current = Date.now();
-        const cache = {
-          val: html,
-          cursor: current
-        };
-        this.container.set(key, JSON.stringify(cache), {
-          ttl
-        });
-      });
-      return renderResult(stream);
-    }
-  }
-  computedKey(req, cacheControl) {
-    const { url } = req;
-    const [pathname] = url.split("?");
-    const { customKey } = cacheControl;
-    const defaultKey = pathname.replace(/.+\/+$/, "");
-    if (customKey) {
-      if (typeof customKey === "string") {
-        return customKey;
-      } else {
-        return customKey(defaultKey);
-      }
-    } else {
-      return defaultKey;
-    }
-  }
-  constructor(container) {
-    _define_property(this, "container", void 0);
-    this.container = container;
-  }
-}
-export {
-  CacheManager
-};