@modern-js/app-tools 2.58.2 → 2.59.0

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

@@ -0,0 +1,202 @@
+import path from "node:path";
+import { fs as fse, pkgUp, semver } from "@modern-js/utils";
+import { parseNodeModulePath } from "mlly";
+import { readPackageJSON } from "pkg-types";
+import { traceFiles as defaultTraceFiles, findEntryFiles, findPackageParents, isFile, isSubPath, linkPackage, readDirRecursive, resolveTracedPath, writePackage } from "./utils";
+import { nodeFileTrace } from "@vercel/nft";
+const handleDependencies = async ({ appDir, serverRootDir, includeEntries, traceFiles = defaultTraceFiles, entryFilter, modifyPackageJson, copyWholePackage, traceOptions }) => {
+  const base = "/";
+  const entryFiles = await findEntryFiles(serverRootDir, entryFilter);
+  const fileTrace = await traceFiles({
+    entryFiles: entryFiles.concat(includeEntries),
+    serverRootDir,
+    base,
+    traceOptions
+  });
+  const currentProjectModules = path.join(appDir, "node_modules");
+  const dependencySearchRoot = path.resolve(appDir, "../../../../../../");
+  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 (isSubPath(serverRootDir, filePath) || isSubPath(appDir, filePath) && !isSubPath(currentProjectModules, filePath)) {
+      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 && isSubPath(dependencySearchRoot, 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 isSubPath(appDir, parent) && !isSubPath(currentProjectModules, parent);
+      }),
+      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.pkgName = pkgName;
+    tracedFile.pkgVersion = pkgJSON.version;
+    const shouldCopyWholePackage = copyWholePackage === null || copyWholePackage === void 0 ? void 0 : copyWholePackage(pkgName);
+    if (tracedFile.path.startsWith(tracedFile.pkgPath) && // Merged package files are based on the version, not on paths, to handle some boundary cases
+    tracedPackageVersion.pkgJSON.version === tracedFile.pkgVersion) {
+      if (shouldCopyWholePackage) {
+        const allFiles = await readDirRecursive(tracedFile.pkgPath);
+        tracedPackageVersion.files.push(...allFiles);
+      } else {
+        tracedPackageVersion.files.push(tracedFile.path);
+      }
+    }
+  }
+  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,
+      projectDir: 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,
+        projectDir: serverRootDir,
+        _pkgPath: 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");
+  const newPkgJson = {
+    name: `${projectPkgJson.name || "modernjs-project"}-prod`,
+    version: projectPkgJson.version || "0.0.0",
+    private: true,
+    type: projectPkgJson.type || "commonjs",
+    dependencies: Object.fromEntries([
+      ...Object.values(tracedPackages).map((pkg) => [
+        pkg.name,
+        Object.keys(pkg.versions)[0]
+      ])
+    ].sort(([a], [b]) => a.localeCompare(b)))
+  };
+  const finalPkgJson = (modifyPackageJson === null || modifyPackageJson === void 0 ? void 0 : modifyPackageJson(newPkgJson)) || newPkgJson;
+  await fse.writeJSON(outputPkgPath, finalPkgJson);
+};
+export {
+  handleDependencies,
+  nodeFileTrace
+};

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

@@ -0,0 +1,137 @@
+import os from "node:os";
+import path from "path";
+import { fs as fse } from "@modern-js/utils";
+import { nodeFileTrace, resolve } from "@vercel/nft";
+import { parseNodeModulePath } from "mlly";
+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 (options) => {
+  const { pkg, version, projectDir, _pkgPath } = options;
+  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) => (
+      // Because it supports copyWholePackage configuration, not all files exist.
+      file === null || file === void 0 ? void 0 : 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.filter((parentPkg) => parentPkg);
+};
+const traceFiles = async ({ entryFiles, serverRootDir, base = "/", traceOptions }) => {
+  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);
+      }
+    },
+    ...traceOptions
+  });
+};
+const resolveTracedPath = async (base, p) => fse.realpath(path.resolve(base, p));
+const isSubPath = (parentPath, childPath) => {
+  if (!parentPath || !childPath) {
+    return false;
+  }
+  const relative = path.relative(parentPath, childPath);
+  return relative && !relative.startsWith("..");
+};
+export {
+  findEntryFiles,
+  findPackageParents,
+  isFile,
+  isSubPath,
+  linkPackage,
+  readDirRecursive,
+  resolveTracedPath,
+  traceFiles,
+  writePackage
+};

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

@@ -0,0 +1,4 @@
+import { handleDependencies } from "./dependencies";
+export {
+  handleDependencies
+};

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

@@ -0,0 +1,44 @@
+import { provider } from "std-env";
+import { createNetlifyPreset } from "./platforms/netlify";
+import { createNodePreset } from "./platforms/node";
+import { createVercelPreset } from "./platforms/vercel";
+import { getProjectUsage } from "./utils";
+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-entry.js

@@ -0,0 +1,11 @@
+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_netlify_entry = __commonJS({
+  "src/plugins/deploy/platforms/netlify-entry.cjs"(exports, module) {
+    const { handler } = require("./netlify-handler");
+    module.exports.default = handler;
+  }
+});
+export default require_netlify_entry();

package/dist/esm-node/plugins/deploy/platforms/netlify-entry.mjs

@@ -0,0 +1 @@
+export { handler as default } from './netlify-handler.cjs';

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

@@ -0,0 +1,71 @@
+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_netlify_handler = __commonJS({
+  "src/plugins/deploy/platforms/netlify-handler.cjs"(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
+        },
+        plugins: p_plugins,
+        ...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 = {
+      handler: async (request, context) => {
+        if (!requestHandler) {
+          await createHandler();
+        }
+        return requestHandler(request, context);
+      }
+    };
+  }
+});
+export default require_netlify_handler();

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

@@ -0,0 +1,117 @@
+import path from "node:path";
+import { DEFAULT_SERVER_CONFIG, ROUTE_SPEC_FILE, fs as fse } from "@modern-js/utils";
+import { isMainEntry } from "../../../utils/routes";
+import { handleDependencies } from "../dependencies";
+import { genPluginImportsCode, serverAppContenxtTemplate } from "../utils";
+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" && item !== "html") {
+        await fse.remove(fullPath);
+      }
+    }
+  } catch (error) {
+    console.error("Error cleaning directory:", error);
+  }
+}
+const createNetlifyPreset = (appContext, modernConfig, needModernServer) => {
+  const { appDirectory, distDirectory, entrypoints, serverPlugins, moduleType } = appContext;
+  const isEsmProject = moduleType === "module";
+  const plugins = serverPlugins.map((plugin) => plugin.name);
+  const netlifyOutput = path.join(appDirectory, ".netlify");
+  const funcsDirectory = path.join(netlifyOutput, "functions");
+  const entryFilePath = path.join(funcsDirectory, "index.js");
+  const handlerFilePath = path.join(funcsDirectory, "netlify-handler.cjs");
+  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: {
+          distPath: {
+            root: "."
+          }
+        }
+      };
+      const pluginImportCode = genPluginImportsCode(plugins || []);
+      const dynamicProdOptions = {
+        config: serverConfig,
+        serverConfigFile: DEFAULT_SERVER_CONFIG
+      };
+      const pluginsCode = `[${plugins.map((plugin, index) => {
+        return `plugin_${index}()`;
+      }).join(",")}]`;
+      let handlerCode = (await fse.readFile(path.join(__dirname, "./netlify-handler.js"))).toString();
+      const serverAppContext = serverAppContenxtTemplate(appContext);
+      handlerCode = handlerCode.replace("p_genPluginImportsCode", pluginImportCode).replace("p_ROUTE_SPEC_FILE", `"${ROUTE_SPEC_FILE}"`).replace("p_dynamicProdOptions", JSON.stringify(dynamicProdOptions)).replace("p_plugins", pluginsCode).replace("p_sharedDirectory", serverAppContext.sharedDirectory).replace("p_apiDirectory", serverAppContext.apiDirectory).replace("p_lambdaDirectory", serverAppContext.lambdaDirectory);
+      await fse.writeFile(handlerFilePath, handlerCode);
+      if (isEsmProject) {
+        await fse.copy(path.join(__dirname, "./netlify-entry.mjs"), entryFilePath);
+      } else {
+        await fse.copy(path.join(__dirname, "./netlify-entry.js"), entryFilePath);
+      }
+    },
+    async end() {
+      if (process.env.NODE_ENV !== "development") {
+        await cleanDistDirectory(distDirectory);
+      }
+      if (!needModernServer) {
+        return;
+      }
+      await handleDependencies({
+        appDir: appDirectory,
+        serverRootDir: funcsDirectory,
+        includeEntries: [
+          require.resolve("@modern-js/prod-server")
+        ]
+      });
+    }
+  };
+};
+export {
+  createNetlifyPreset
+};

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

@@ -0,0 +1,44 @@
+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
+    },
+    plugins: p_plugins,
+    ...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();