@modern-js/app-tools 2.50.0 → 2.51.0

package/dist/esm-node/plugins/deploy/dependencies/index.js

@@ -0,0 +1,183 @@
+import path, { isAbsolute } from "node:path";
+import { fs as fse, pkgUp, semver } from "@modern-js/utils";
+import { readPackageJSON } from "pkg-types";
+import { parseNodeModulePath } from "mlly";
+import { linkPackage, writePackage, isFile, findEntryFiles, traceFiles, findPackageParents, resolveTracedPath } from "./utils";
+const handleDependencies = async (appDir, serverRootDir, include, entryFilter) => {
+  const base = "/";
+  const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
+  const includeEntries = include.map((item) => {
+    if (isAbsolute(item)) {
+      return item;
+    }
+    try {
+      return require.resolve(item);
+    } catch (error) {
+    }
+    return item;
+  });
+  const fileTrace = await traceFiles(entryFiles.concat(includeEntries), serverRootDir, base);
+  const currentProjectModules = path.join(appDir, "node_modules");
+  const tracedFiles = Object.fromEntries(await Promise.all([
+    ...fileTrace.reasons.entries()
+  ].map(async ([_path, reasons]) => {
+    if (reasons.ignored) {
+      return;
+    }
+    const filePath = await resolveTracedPath(base, _path);
+    if (filePath.startsWith(serverRootDir) || filePath.startsWith(appDir) && !filePath.startsWith(currentProjectModules)) {
+      return;
+    }
+    if (!await isFile(filePath)) {
+      return;
+    }
+    let baseDir;
+    let pkgName;
+    let subpath;
+    let pkgPath;
+    if (filePath.includes("node_modules")) {
+      const parsed = parseNodeModulePath(filePath);
+      baseDir = parsed.dir;
+      pkgName = parsed.name;
+      subpath = parsed.subpath;
+      pkgPath = path.join(baseDir, pkgName);
+    } else {
+      const MODERN_UTILS_PATH = "packages/toolkit/utils";
+      const MODERN_UTILS_PATH_REGEX = new RegExp(`(.*${MODERN_UTILS_PATH})`);
+      const match = filePath.match(MODERN_UTILS_PATH_REGEX);
+      const packageJsonPath = match ? path.join(match[0], "package.json") : await pkgUp({
+        cwd: path.dirname(filePath)
+      });
+      if (packageJsonPath) {
+        const packageJson = await fse.readJSON(packageJsonPath);
+        pkgPath = baseDir = path.dirname(packageJsonPath);
+        subpath = path.relative(baseDir, filePath);
+        pkgName = packageJson.name;
+      }
+    }
+    if (!baseDir) {
+      return;
+    }
+    const parents = await Promise.all([
+      ...reasons.parents
+    ].map((p) => resolveTracedPath(base, p)));
+    const tracedFile = {
+      path: filePath,
+      parents,
+      isDirectDep: parents.some((parent) => {
+        return parent.startsWith(appDir) && !parent.startsWith(currentProjectModules);
+      }),
+      subpath,
+      pkgName,
+      pkgPath
+    };
+    return [
+      filePath,
+      tracedFile
+    ];
+  })).then((r) => r.filter(Boolean)));
+  const tracedPackages = {};
+  for (const tracedFile of Object.values(tracedFiles)) {
+    const { pkgName } = tracedFile;
+    let tracedPackage = tracedPackages[pkgName];
+    let pkgJSON = await readPackageJSON(tracedFile.pkgPath, {
+      cache: true
+    }).catch(() => {
+    });
+    if (!pkgJSON) {
+      pkgJSON = {
+        name: pkgName,
+        version: "0.0.0"
+      };
+    }
+    if (!tracedPackage) {
+      tracedPackage = {
+        name: pkgName,
+        versions: {}
+      };
+      tracedPackages[pkgName] = tracedPackage;
+    }
+    let tracedPackageVersion = tracedPackage.versions[pkgJSON.version];
+    if (!tracedPackageVersion) {
+      tracedPackageVersion = {
+        path: tracedFile.pkgPath,
+        files: [],
+        isDirectDep: false,
+        pkgJSON
+      };
+      if (tracedFile.isDirectDep) {
+        tracedPackageVersion.isDirectDep = tracedFile.isDirectDep;
+      }
+      tracedPackage.versions[pkgJSON.version] = tracedPackageVersion;
+    }
+    tracedFile.path.startsWith(tracedFile.pkgPath) && tracedPackageVersion.path === tracedFile.pkgPath && tracedPackageVersion.files.push(tracedFile.path);
+    tracedFile.pkgName = pkgName;
+    tracedFile.pkgVersion = pkgJSON.version;
+  }
+  const multiVersionPkgs = {};
+  const singleVersionPackages = [];
+  for (const tracedPackage of Object.values(tracedPackages)) {
+    const versions = Object.keys(tracedPackage.versions);
+    if (versions.length === 1) {
+      singleVersionPackages.push(tracedPackage.name);
+      continue;
+    }
+    multiVersionPkgs[tracedPackage.name] = {};
+    for (const version of versions) {
+      multiVersionPkgs[tracedPackage.name][version] = findPackageParents(tracedPackage, version, tracedFiles);
+    }
+  }
+  await Promise.all(singleVersionPackages.map((pkgName) => {
+    const pkg = tracedPackages[pkgName];
+    const version = Object.keys(pkg.versions)[0];
+    return writePackage(pkg, version, serverRootDir);
+  }));
+  const projectPkgJson = await readPackageJSON(serverRootDir).catch(() => ({}));
+  for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
+    const versionEntires = Object.entries(pkgVersions).sort(([v1, p1], [v2, p2]) => {
+      var _tracedPackages_pkgName_versions_v1, _tracedPackages_pkgName_versions, _tracedPackages_pkgName, _tracedPackages_pkgName_versions_v2, _tracedPackages_pkgName_versions1, _tracedPackages_pkgName1;
+      const shouldHoist1 = (_tracedPackages_pkgName = tracedPackages[pkgName]) === null || _tracedPackages_pkgName === void 0 ? void 0 : (_tracedPackages_pkgName_versions = _tracedPackages_pkgName.versions) === null || _tracedPackages_pkgName_versions === void 0 ? void 0 : (_tracedPackages_pkgName_versions_v1 = _tracedPackages_pkgName_versions[v1]) === null || _tracedPackages_pkgName_versions_v1 === void 0 ? void 0 : _tracedPackages_pkgName_versions_v1.isDirectDep;
+      const shouldHoist2 = (_tracedPackages_pkgName1 = tracedPackages[pkgName]) === null || _tracedPackages_pkgName1 === void 0 ? void 0 : (_tracedPackages_pkgName_versions1 = _tracedPackages_pkgName1.versions) === null || _tracedPackages_pkgName_versions1 === void 0 ? void 0 : (_tracedPackages_pkgName_versions_v2 = _tracedPackages_pkgName_versions1[v2]) === null || _tracedPackages_pkgName_versions_v2 === void 0 ? void 0 : _tracedPackages_pkgName_versions_v2.isDirectDep;
+      if (shouldHoist1 && !shouldHoist2) {
+        return -1;
+      }
+      if (!shouldHoist1 && shouldHoist2) {
+        return 1;
+      }
+      if (p1.length === 0) {
+        return -1;
+      }
+      if (p2.length === 0) {
+        return 1;
+      }
+      return semver.lt(v1, v2, {
+        loose: true
+      }) ? 1 : -1;
+    });
+    for (const [version, parentPkgs] of versionEntires) {
+      const pkg = tracedPackages[pkgName];
+      const pkgDestPath = `.modernjs/${pkgName}@${version}/node_modules/${pkgName}`;
+      await writePackage(pkg, version, serverRootDir, pkgDestPath);
+      await linkPackage(pkgDestPath, `${pkgName}`, serverRootDir);
+      for (const parentPkg of parentPkgs) {
+        const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
+        await (multiVersionPkgs[parentPkgName] ? linkPackage(pkgDestPath, `.modernjs/${parentPkg}/node_modules/${pkgName}`, serverRootDir) : linkPackage(pkgDestPath, `${parentPkgName}/node_modules/${pkgName}`, serverRootDir));
+      }
+    }
+  }
+  const outputPkgPath = path.join(serverRootDir, "package.json");
+  await fse.writeJSON(outputPkgPath, {
+    name: `${projectPkgJson.name || "modernjs-project"}-prod`,
+    version: projectPkgJson.version || "0.0.0",
+    private: true,
+    dependencies: Object.fromEntries([
+      ...Object.values(tracedPackages).map((pkg) => [
+        pkg.name,
+        Object.keys(pkg.versions)[0]
+      ])
+    ].sort(([a], [b]) => a.localeCompare(b)))
+  });
+};
+export {
+  handleDependencies
+};

package/dist/esm-node/plugins/deploy/dependencies/utils.js

@@ -0,0 +1,124 @@
+import path from "path";
+import os from "node:os";
+import { fs as fse } from "@modern-js/utils";
+import { parseNodeModulePath } from "mlly";
+import { nodeFileTrace, resolve } from "@vercel/nft";
+function applyPublicCondition(pkg) {
+  var _pkg_publishConfig;
+  if (pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig = pkg.publishConfig) === null || _pkg_publishConfig === void 0 ? void 0 : _pkg_publishConfig.exports) {
+    var _pkg_publishConfig1;
+    pkg.exports = pkg === null || pkg === void 0 ? void 0 : (_pkg_publishConfig1 = pkg.publishConfig) === null || _pkg_publishConfig1 === void 0 ? void 0 : _pkg_publishConfig1.exports;
+  }
+}
+const writePackage = async (pkg, version, projectDir, _pkgPath) => {
+  const pkgPath = _pkgPath || pkg.name;
+  for (const src of pkg.versions[version].files) {
+    if (src.includes("node_modules")) {
+      const { subpath } = parseNodeModulePath(src);
+      const dest = path.join(projectDir, "node_modules", pkgPath, subpath);
+      const dirname = path.dirname(dest);
+      await fse.ensureDir(dirname);
+      await fse.copyFile(src, dest);
+    } else {
+      const subpath = path.relative(pkg.versions[version].path, src);
+      const dest = path.join(projectDir, "node_modules", pkgPath, subpath);
+      const dirname = path.dirname(dest);
+      await fse.ensureDir(dirname);
+      await fse.copyFile(src, dest);
+    }
+  }
+  const { pkgJSON } = pkg.versions[version];
+  applyPublicCondition(pkgJSON);
+  const packageJsonPath = path.join(projectDir, "node_modules", pkgPath, "package.json");
+  await fse.ensureDir(path.dirname(packageJsonPath));
+  await fse.writeFile(packageJsonPath, JSON.stringify(pkgJSON, null, 2));
+};
+const isWindows = os.platform() === "win32";
+const linkPackage = async (from, to, projectRootDir) => {
+  const src = path.join(projectRootDir, "node_modules", from);
+  const dest = path.join(projectRootDir, "node_modules", to);
+  const dstStat = await fse.lstat(dest).catch(() => null);
+  const exists = dstStat === null || dstStat === void 0 ? void 0 : dstStat.isSymbolicLink();
+  if (exists) {
+    return;
+  }
+  await fse.mkdir(path.dirname(dest), {
+    recursive: true
+  });
+  await fse.symlink(path.relative(path.dirname(dest), src), dest, isWindows ? "junction" : "dir").catch((error) => {
+    console.error("Cannot link", from, "to", to, error);
+  });
+};
+const readDirRecursive = async (dir, options = {}) => {
+  const { filter } = options;
+  const files = await fse.readdir(dir, {
+    withFileTypes: true
+  });
+  const filesAndDirs = await Promise.all(files.map(async (file) => {
+    const resolvedPath = path.resolve(dir, file.name);
+    if (file.isDirectory()) {
+      return readDirRecursive(resolvedPath, options);
+    } else {
+      return filter && !filter(resolvedPath) ? [] : resolvedPath;
+    }
+  }));
+  return filesAndDirs.flat();
+};
+const isFile = async (file) => {
+  try {
+    const stat = await fse.stat(file);
+    return stat.isFile();
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+};
+const findEntryFiles = async (rootDir, entryFilter) => {
+  const files = await readDirRecursive(rootDir, {
+    filter: entryFilter
+  });
+  return files.filter((file) => file.endsWith(".mjs") || file.endsWith(".cjs") || file.endsWith(".js"));
+};
+const findPackageParents = (pkg, version, tracedFiles) => {
+  const versionFiles = pkg.versions[version].files.map((path2) => tracedFiles[path2]);
+  const parentPkgs = [
+    ...new Set(versionFiles.flatMap((file) => file.parents.map((parentPath) => {
+      const parentFile = tracedFiles[parentPath];
+      if (!parentFile || parentFile.pkgName === pkg.name) {
+        return null;
+      }
+      return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
+    }).filter(Boolean)))
+  ];
+  return parentPkgs;
+};
+const traceFiles = async (entryFiles, serverRootDir, base = "/") => {
+  return await nodeFileTrace(entryFiles, {
+    base,
+    processCwd: serverRootDir,
+    resolve: async (id, parent, job, isCjs) => {
+      if (id.startsWith("@modern-js/prod-server")) {
+        return require.resolve(id, {
+          paths: [
+            require.resolve("@modern-js/app-tools")
+          ]
+        });
+      } else {
+        return resolve(id, parent, job, isCjs);
+      }
+    }
+  });
+};
+const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));
+export {
+  findEntryFiles,
+  findPackageParents,
+  isFile,
+  linkPackage,
+  readDirRecursive,
+  resolveTracedPath,
+  traceFiles,
+  writePackage
+};

package/dist/esm-node/plugins/deploy/index.js

@@ -0,0 +1,44 @@
+import { provider } from "std-env";
+import { getProjectUsage } from "./utils";
+import { createNodePreset } from "./platforms/node";
+import { createVercelPreset } from "./platforms/vercel";
+import { createNetlifyPreset } from "./platforms/netlify";
+const deployPresets = {
+  node: createNodePreset,
+  vercel: createVercelPreset,
+  netlify: createNetlifyPreset
+};
+async function getDeployPreset(appContext, modernConfig, deployTarget) {
+  const { appDirectory, distDirectory } = appContext;
+  const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory);
+  const needModernServer = useSSR || useAPI || useWebServer;
+  const createPreset = deployPresets[deployTarget];
+  if (!createPreset) {
+    throw new Error(`Unknown deploy target: '${deployTarget}'. MODERNJS_DEPLOY should be 'node', 'vercel', or 'netlify'.`);
+  }
+  return createPreset(appContext, modernConfig, needModernServer);
+}
+var deploy_default = () => ({
+  name: "@modern-js/plugin-deploy",
+  setup: (api) => {
+    const deployTarget = process.env.MODERNJS_DEPLOY || provider || "node";
+    return {
+      async deploy() {
+        const appContext = api.useAppContext();
+        const { metaName } = appContext;
+        if (metaName !== "modern-js" && !process.env.MODERNJS_DEPLOY) {
+          return;
+        }
+        const modernConfig = api.useResolvedConfigContext();
+        const deployPreset = await getDeployPreset(appContext, modernConfig, deployTarget);
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.prepare());
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.writeOutput());
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.genEntry());
+        (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end) && await (deployPreset === null || deployPreset === void 0 ? void 0 : deployPreset.end());
+      }
+    };
+  }
+});
+export {
+  deploy_default as default
+};

package/dist/esm-node/plugins/deploy/platforms/netlify.js

@@ -0,0 +1,102 @@
+import path from "node:path";
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse, getInternalPlugins } from "@modern-js/utils";
+import { isMainEntry } from "../../../utils/routes";
+import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
+import { handleDependencies } from "../dependencies";
+async function cleanDistDirectory(dir) {
+  try {
+    const items = await fse.readdir(dir);
+    for (const item of items) {
+      const fullPath = path.join(dir, item);
+      if (item !== "static" && item !== "_redirects") {
+        await fse.remove(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error("Error cleaning directory:", error);
+  }
+}
+const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
+  const { appDirectory, distDirectory, serverInternalPlugins, entrypoints } = appContext;
+  const plugins = getInternalPlugins(appDirectory, serverInternalPlugins);
+  const netlifyOutput = path.join(appDirectory, ".netlify");
+  const funcsDirectory = path.join(netlifyOutput, "functions");
+  const entryFilePath = path.join(funcsDirectory, "index.js");
+  return {
+    async prepare() {
+      await fse.remove(netlifyOutput);
+    },
+    async writeOutput() {
+      const routes = [];
+      const { source: { mainEntryName } } = modernConfig;
+      if (!needModernServer) {
+        entrypoints.forEach((entry) => {
+          const isMain = isMainEntry(entry.entryName, mainEntryName);
+          routes.push({
+            src: `/${isMain ? "" : `${entry.entryName}/`}*`,
+            dest: `/html/${entry.entryName}/index.html`,
+            status: 200
+          });
+        });
+      } else {
+        routes.push({
+          src: "/*",
+          dest: `/.netlify/functions/index`,
+          status: 200
+        });
+      }
+      const redirectContent = routes.map((route) => {
+        return `${route.src} ${route.dest} ${route.status}`;
+      }).join("\n");
+      if (needModernServer) {
+        await fse.ensureDir(funcsDirectory);
+        await fse.copy(distDirectory, funcsDirectory, {
+          filter: (src) => {
+            const distStaticDirectory = path.join(distDirectory, `static`);
+            return !src.includes(distStaticDirectory);
+          }
+        });
+      }
+      const redirectFilePath = path.join(distDirectory, "_redirects");
+      await fse.writeFile(redirectFilePath, redirectContent);
+    },
+    async genEntry() {
+      var _modernConfig_bff;
+      if (!needModernServer) {
+        return;
+      }
+      const serverConfig = {
+        bff: {
+          prefix: modernConfig === null || modernConfig === void 0 ? void 0 : (_modernConfig_bff = modernConfig.bff) === null || _modernConfig_bff === void 0 ? void 0 : _modernConfig_bff.prefix
+        },
+        output: {
+          path: "."
+        }
+      };
+      const pluginImportCode = genPluginImportsCode(plugins || []);
+      const dynamicProdOptions = {
+        config: serverConfig,
+        serverConfigFile: DEFAULT_SERVER_CONFIG,
+        plugins
+      };
+      let entryCode = (await fse.readFile(path.join(__dirname, "./netlifyEntry.js"))).toString();
+      const serverAppContext = serverAppContenxtTemplate(appContext);
+      entryCode = entryCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      await fse.writeFile(entryFilePath, entryCode);
+    },
+    async end() {
+      if (process.env.NODE_ENV !== "test" && process.env.NODE_ENV !== "development") {
+        await cleanDistDirectory(distDirectory);
+      }
+      if (!needModernServer) {
+        return;
+      }
+      await handleDependencies(appDirectory, funcsDirectory, [
+        "@modern-js/prod-server"
+      ]);
+    }
+  };
+};
+export {
+  createNetlifyPreset
+};

package/dist/esm-node/plugins/deploy/platforms/netlifyEntry.js

@@ -0,0 +1,68 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var require_netlifyEntry = __commonJS({
+  "src/plugins/deploy/platforms/netlifyEntry.js"(exports, module) {
+    const fs = require("node:fs/promises");
+    const path = require("node:path");
+    const { createNetlifyFunction } = require("@modern-js/prod-server/netlify");
+    p_genPluginImportsCode;
+    if (!process.env.NODE_ENV) {
+      process.env.NODE_ENV = "production";
+    }
+    let requestHandler = null;
+    let handlerCreationPromise = null;
+    async function loadRoutes(routeFilepath) {
+      try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, "utf-8");
+        const routeSpec = JSON.parse(content);
+        return routeSpec.routes || [];
+      } catch (error) {
+        console.warn("route.json not found or invalid, continuing with empty routes.");
+        return [];
+      }
+    }
+    async function initServer() {
+      const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+      const routes = await loadRoutes(routeFilepath);
+      const dynamicProdOptions = p_dynamicProdOptions;
+      const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        disableCustomHook: true,
+        appContext: {
+          sharedDirectory: p_sharedDirectory,
+          apiDirectory: p_apiDirectory,
+          lambdaDirectory: p_lambdaDirectory
+        },
+        ...dynamicProdOptions
+      };
+      const requestHandler2 = await createNetlifyFunction(prodServerOptions);
+      return requestHandler2;
+    }
+    async function createHandler() {
+      if (!handlerCreationPromise) {
+        handlerCreationPromise = (async () => {
+          try {
+            requestHandler = await initServer();
+          } catch (error) {
+            console.error("Error creating server:", error);
+            process.exit(1);
+          }
+        })();
+      }
+      await handlerCreationPromise;
+      return requestHandler;
+    }
+    createHandler();
+    module.exports.default = async (request, context) => {
+      if (!requestHandler) {
+        await createHandler();
+      }
+      return requestHandler(request, context);
+    };
+  }
+});
+export default require_netlifyEntry();

package/dist/esm-node/plugins/deploy/platforms/node.js

@@ -0,0 +1,56 @@
+import path from "node:path";
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG, fs as fse, getInternalPlugins, chalk } from "@modern-js/utils";
+import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
+import { handleDependencies } from "../dependencies";
+const createNodePreset = (appContext, config) => {
+  const { appDirectory, distDirectory, serverInternalPlugins } = appContext;
+  const plugins = getInternalPlugins(appDirectory, serverInternalPlugins);
+  const outputDirectory = path.join(appDirectory, ".output");
+  const staticDirectory = path.join(outputDirectory, "static");
+  const entryFilePath = path.join(outputDirectory, "index.js");
+  return {
+    async prepare() {
+      await fse.remove(outputDirectory);
+    },
+    async writeOutput() {
+      await fse.copy(distDirectory, outputDirectory);
+    },
+    async genEntry() {
+      var _config_bff;
+      const serverConfig = {
+        server: {
+          port: 8080
+        },
+        bff: {
+          prefix: config === null || config === void 0 ? void 0 : (_config_bff = config.bff) === null || _config_bff === void 0 ? void 0 : _config_bff.prefix
+        },
+        output: {
+          path: "."
+        }
+      };
+      const pluginImportCode = genPluginImportsCode(plugins || []);
+      const dynamicProdOptions = {
+        config: serverConfig,
+        serverConfigFile: DEFAULT_SERVER_CONFIG,
+        plugins
+      };
+      let entryCode = (await fse.readFile(path.join(__dirname, "./nodeEntry.js"))).toString();
+      const serverAppContext = serverAppContenxtTemplate(appContext);
+      entryCode = entryCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      await fse.writeFile(entryFilePath, entryCode);
+    },
+    async end() {
+      console.log("Static directory:", chalk.blue(path.relative(appDirectory, staticDirectory)));
+      console.log(`You can preview this build by`, chalk.blue(`node .output/index`));
+      const filter = (filePath) => {
+        return !filePath.startsWith(staticDirectory);
+      };
+      await handleDependencies(appDirectory, outputDirectory, [
+        "@modern-js/prod-server"
+      ], filter);
+    }
+  };
+};
+export {
+  createNodePreset
+};

package/dist/esm-node/plugins/deploy/platforms/nodeEntry.js

@@ -0,0 +1,43 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const { createProdServer } = require("@modern-js/prod-server");
+p_genPluginImportsCode;
+if (!process.env.NODE_ENV) {
+  process.env.NODE_ENV = "production";
+}
+async function loadRoutes(routeFilepath) {
+  try {
+    await fs.access(routeFilepath);
+    const content = await fs.readFile(routeFilepath, "utf-8");
+    const routeSpec = JSON.parse(content);
+    return routeSpec.routes || [];
+  } catch (error) {
+    console.warn("route.json not found or invalid, continuing with empty routes.");
+    return [];
+  }
+}
+async function main() {
+  const routeFilepath = path.join(__dirname, p_ROUTE_SPEC_FILE);
+  const routes = await loadRoutes(routeFilepath);
+  const dynamicProdOptions = p_dynamicProdOptions;
+  const prodServerOptions = {
+    pwd: __dirname,
+    routes,
+    disableCustomHook: true,
+    appContext: {
+      sharedDirectory: p_sharedDirectory,
+      apiDirectory: p_apiDirectory,
+      lambdaDirectory: p_lambdaDirectory
+    },
+    ...dynamicProdOptions
+  };
+  const app = await createProdServer(prodServerOptions);
+  const port = process.env.PORT || 8080;
+  app.listen({
+    host: "::",
+    port
+  }, () => {
+    console.log(`\x1B[32mServer is listening on http://[::]:${port}`, "\x1B[0m");
+  });
+}
+main();