@modern-js/app-tools 2.48.6 → 2.49.1-alpha.0

package/dist/esm/utils/register.js

@@ -0,0 +1,129 @@
+import { _ as _async_to_generator } from "@swc/helpers/_/_async_to_generator";
+import { _ as _define_property } from "@swc/helpers/_/_define_property";
+import { _ as _object_spread } from "@swc/helpers/_/_object_spread";
+import { _ as _object_spread_props } from "@swc/helpers/_/_object_spread_props";
+import { _ as _ts_generator } from "@swc/helpers/_/_ts_generator";
+import path from "node:path";
+import { fs, getAliasConfig, readTsConfigByFile } from "@modern-js/utils";
+var registerCompiler = function() {
+  var _ref = _async_to_generator(function() {
+    var appDir, distDir, alias, TS_CONFIG_FILENAME, tsconfigPath, isTsProject, aliasConfig, _aliasConfig_paths, paths, _aliasConfig_absoluteBaseUrl, absoluteBaseUrl, tsPaths, tsConfig, tsNode, tsNodeOptions, error, esbuildRegister, tsConfigPaths, loaderRes;
+    var _arguments = arguments;
+    return _ts_generator(this, function(_state) {
+      switch (_state.label) {
+        case 0:
+          appDir = _arguments.length > 0 && _arguments[0] !== void 0 ? _arguments[0] : process.cwd(), distDir = _arguments.length > 1 ? _arguments[1] : void 0, alias = _arguments.length > 2 ? _arguments[2] : void 0;
+          TS_CONFIG_FILENAME = "tsconfig.json";
+          tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
+          return [
+            4,
+            fs.pathExists(tsconfigPath)
+          ];
+        case 1:
+          isTsProject = _state.sent();
+          aliasConfig = getAliasConfig(alias, {
+            appDirectory: appDir,
+            tsconfigPath
+          });
+          _aliasConfig_paths = aliasConfig.paths, paths = _aliasConfig_paths === void 0 ? {} : _aliasConfig_paths, _aliasConfig_absoluteBaseUrl = aliasConfig.absoluteBaseUrl, absoluteBaseUrl = _aliasConfig_absoluteBaseUrl === void 0 ? "./" : _aliasConfig_absoluteBaseUrl;
+          tsPaths = Object.keys(paths).reduce(function(o, key) {
+            var tsPath = paths[key];
+            if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
+              tsPath = path.relative(absoluteBaseUrl, tsPath);
+            }
+            if (typeof tsPath === "string") {
+              tsPath = [
+                tsPath
+              ];
+            }
+            return _object_spread_props(_object_spread({}, o), _define_property({}, "".concat(key), tsPath));
+          }, {});
+          tsConfig = {};
+          if (isTsProject) {
+            tsConfig = readTsConfigByFile(tsconfigPath);
+          }
+          _state.label = 2;
+        case 2:
+          _state.trys.push([
+            2,
+            4,
+            ,
+            6
+          ]);
+          return [
+            4,
+            import("ts-node")
+          ];
+        case 3:
+          tsNode = _state.sent();
+          tsNodeOptions = tsConfig["ts-node"];
+          if (isTsProject) {
+            tsNode.register(_object_spread({
+              project: tsconfigPath,
+              scope: true,
+              // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
+              files: true,
+              transpileOnly: true,
+              ignore: [
+                "(?:^|/)node_modules/",
+                "(?:^|/)".concat(distDir, "/")
+              ]
+            }, tsNodeOptions));
+          }
+          return [
+            3,
+            6
+          ];
+        case 4:
+          error = _state.sent();
+          return [
+            4,
+            import("esbuild-register/dist/node")
+          ];
+        case 5:
+          esbuildRegister = _state.sent();
+          esbuildRegister.register({
+            tsconfigRaw: isTsProject ? tsConfig : void 0,
+            hookIgnoreNodeModules: true,
+            hookMatcher: function(fileName) {
+              return !fileName.startsWith(distDir);
+            }
+          });
+          return [
+            3,
+            6
+          ];
+        case 6:
+          return [
+            4,
+            import("@modern-js/utils/tsconfig-paths")
+          ];
+        case 7:
+          tsConfigPaths = _state.sent();
+          return [
+            4,
+            fs.pathExists(appDir)
+          ];
+        case 8:
+          if (_state.sent()) {
+            loaderRes = tsConfigPaths.loadConfig(appDir);
+            if (loaderRes.resultType === "success") {
+              tsConfigPaths.register({
+                baseUrl: absoluteBaseUrl || "./",
+                paths: tsPaths
+              });
+            }
+          }
+          return [
+            2
+          ];
+      }
+    });
+  });
+  return function registerCompiler2() {
+    return _ref.apply(this, arguments);
+  };
+}();
+export {
+  registerCompiler
+};

package/dist/esm-node/builder/builder-webpack/index.js

@@ -5,7 +5,7 @@ async function createWebpackBuilderForModern(options) {
   const { normalizedConfig } = options;
   if (normalizedConfig.tools.esbuild) {
     const { esbuild: esbuildOptions } = normalizedConfig.tools;
-    const { pluginEsbuild } = await import("@rsbuild/plugin-esbuild");
+    const { pluginEsbuild } = await import("@modern-js/rsbuild-plugin-esbuild");
     builder.addPlugins([
       pluginEsbuild(esbuildOptions)
     ]);

package/dist/esm-node/commands/build.js

@@ -2,13 +2,16 @@ import { ResolvedConfigContext } from "@modern-js/core";
 import { logger } from "@modern-js/utils";
 import { generateRoutes } from "../utils/routes";
 import { buildServerConfig } from "../utils/config";
+import { registerCompiler } from "../utils/register";
 const build = async (api, options) => {
+  var _resolvedConfig_source;
   if (options === null || options === void 0 ? void 0 : options.analyze) {
     process.env.BUNDLE_ANALYZE = "true";
   }
   let resolvedConfig = api.useResolvedConfigContext();
   const appContext = api.useAppContext();
   const hookRunners = api.useHookRunners();
+  await registerCompiler(appContext.appDirectory, appContext.distDirectory, resolvedConfig === null || resolvedConfig === void 0 ? void 0 : (_resolvedConfig_source = resolvedConfig.source) === null || _resolvedConfig_source === void 0 ? void 0 : _resolvedConfig_source.alias);
   const { apiOnly } = appContext;
   if (apiOnly) {
     const { appDirectory: appDirectory2, distDirectory: distDirectory2, serverConfigFile: serverConfigFile2 } = appContext;

package/dist/esm-node/commands/dev.js

@@ -1,24 +1,28 @@
 import { ResolvedConfigContext } from "@modern-js/core";
 import { DEFAULT_DEV_HOST } from "@modern-js/utils";
+import { createDevServer } from "@modern-js/server";
+import { initProdMiddlewares } from "@modern-js/prod-server";
+import { registerCompiler } from "../utils/register";
 import { printInstructions } from "../utils/printInstructions";
-import { setServer, createServer, injectDataLoaderPlugin } from "../utils/createServer";
+import { setServer } from "../utils/createServer";
 import { generateRoutes } from "../utils/routes";
 import { buildServerConfig } from "../utils/config";
 import { getServerInternalPlugins } from "../utils/getServerInternalPlugins";
 const dev = async (api, options, devServerOptions = {}) => {
-  var _normalizedConfig_tools;
+  var _normalizedConfig_source, _normalizedConfig_tools;
   if (options.analyze) {
     process.env.BUNDLE_ANALYZE = "true";
   }
   let normalizedConfig = api.useResolvedConfigContext();
   const appContext = api.useAppContext();
   const hookRunners = api.useHookRunners();
+  await registerCompiler(appContext.appDirectory, appContext.distDirectory, normalizedConfig === null || normalizedConfig === void 0 ? void 0 : (_normalizedConfig_source = normalizedConfig.source) === null || _normalizedConfig_source === void 0 ? void 0 : _normalizedConfig_source.alias);
   normalizedConfig = {
     ...normalizedConfig,
     cliOptions: options
   };
   ResolvedConfigContext.set(normalizedConfig);
-  const { appDirectory, distDirectory, port, apiOnly, serverConfigFile, metaName } = appContext;
+  const { appDirectory, distDirectory, port, apiOnly, serverConfigFile, metaName, serverRoutes } = appContext;
   await buildServerConfig({
     appDirectory,
     distDirectory,
@@ -32,6 +36,7 @@ const dev = async (api, options, devServerOptions = {}) => {
   await generateRoutes(appContext);
   const serverInternalPlugins = await getServerInternalPlugins(api);
   const serverOptions = {
+    metaName,
     dev: {
       port,
       https: normalizedConfig.dev.https,
@@ -39,37 +44,32 @@ const dev = async (api, options, devServerOptions = {}) => {
       ...(_normalizedConfig_tools = normalizedConfig.tools) === null || _normalizedConfig_tools === void 0 ? void 0 : _normalizedConfig_tools.devServer
     },
     appContext: {
-      metaName,
-      appDirectory: appContext.appDirectory,
-      sharedDirectory: appContext.sharedDirectory,
+      appDirectory,
       apiDirectory: appContext.apiDirectory,
-      lambdaDirectory: appContext.lambdaDirectory
+      lambdaDirectory: appContext.lambdaDirectory,
+      sharedDirectory: appContext.sharedDirectory
     },
+    routes: serverRoutes,
     pwd: appDirectory,
     config: normalizedConfig,
     serverConfigFile,
-    internalPlugins: injectDataLoaderPlugin(serverInternalPlugins),
+    internalPlugins: serverInternalPlugins,
     ...devServerOptions
   };
   if (apiOnly) {
     var _normalizedConfig_dev;
-    const app = await createServer({
-      ...serverOptions,
-      compiler: null
-    });
+    const app = await createDevServer(serverOptions, initProdMiddlewares);
     const host = ((_normalizedConfig_dev = normalizedConfig.dev) === null || _normalizedConfig_dev === void 0 ? void 0 : _normalizedConfig_dev.host) || DEFAULT_DEV_HOST;
     app.listen({
       port,
       host
-    }, async (err) => {
-      if (err) {
-        throw err;
-      }
+    }, () => {
       printInstructions(hookRunners, appContext, normalizedConfig);
     });
   } else {
     const { server } = await appContext.builder.startDevServer({
-      serverOptions
+      serverOptions,
+      initProdMiddlewares
     });
     setServer(server);
   }

package/dist/esm-node/commands/serve.js

@@ -1,19 +1,23 @@
 import { logger, isApiOnly, getTargetDir } from "@modern-js/utils";
-import server from "@modern-js/prod-server";
+import { createProdServer } from "@modern-js/prod-server";
 import { printInstructions } from "../utils/printInstructions";
-import { injectDataLoaderPlugin } from "../utils/createServer";
 import { getServerInternalPlugins } from "../utils/getServerInternalPlugins";
 const start = async (api) => {
   var _userConfig_source, _userConfig_output_distPath;
   const appContext = api.useAppContext();
   const userConfig = api.useResolvedConfigContext();
   const hookRunners = api.useHookRunners();
-  const { appDirectory, port, serverConfigFile, metaName } = appContext;
+  const { distDirectory, appDirectory, port, serverConfigFile, metaName, serverRoutes } = appContext;
   logger.info(`Starting production server...`);
   const apiOnly = await isApiOnly(appContext.appDirectory, userConfig === null || userConfig === void 0 ? void 0 : (_userConfig_source = userConfig.source) === null || _userConfig_source === void 0 ? void 0 : _userConfig_source.entriesDir, appContext.apiDirectory);
+  let runMode;
+  if (apiOnly) {
+    runMode = "apiOnly";
+  }
   const serverInternalPlugins = await getServerInternalPlugins(api);
-  const app = await server({
-    pwd: appDirectory,
+  const app = await createProdServer({
+    metaName,
+    pwd: distDirectory,
     config: {
       ...userConfig,
       dev: userConfig.dev,
@@ -22,20 +26,18 @@ const start = async (api) => {
         ...userConfig.output || {}
       }
     },
+    routes: serverRoutes,
     appContext: {
-      metaName,
+      appDirectory,
       sharedDirectory: getTargetDir(appContext.sharedDirectory, appContext.appDirectory, appContext.distDirectory),
       apiDirectory: getTargetDir(appContext.apiDirectory, appContext.appDirectory, appContext.distDirectory),
       lambdaDirectory: getTargetDir(appContext.lambdaDirectory, appContext.appDirectory, appContext.distDirectory)
     },
     serverConfigFile,
-    internalPlugins: injectDataLoaderPlugin(serverInternalPlugins),
-    apiOnly
+    internalPlugins: serverInternalPlugins,
+    runMode
   });
-  app.listen(port, async (err) => {
-    if (err) {
-      throw err;
-    }
+  app.listen(port, async () => {
     await printInstructions(hookRunners, appContext, userConfig);
   });
 };

package/dist/esm-node/index.js

@@ -8,6 +8,7 @@ import initializePlugin from "./initialize";
 import { hooks } from "./hooks";
 import { i18n, localeKeys } from "./locale";
 import serverBuildPlugin from "./plugins/serverBuild";
+import deployPlugin from "./plugins/deploy";
 import { restart } from "./utils/restart";
 import { generateWatchFiles } from "./utils/generateWatchFiles";
 import { mergeConfig } from "@modern-js/core";
@@ -81,7 +82,8 @@ const appTools = (options = {
       bundler: (options === null || options === void 0 ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
     }),
     serverBuildPlugin(),
-    lintPlugin()
+    lintPlugin(),
+    deployPlugin()
   ],
   setup: (api) => {
     const appContext = api.useAppContext();

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

@@ -0,0 +1,223 @@
+import path, { isAbsolute } from "node:path";
+import { nodeFileTrace, resolve } from "@vercel/nft";
+import { fs as fse, pkgUp } from "@modern-js/utils";
+import { readPackageJSON } from "pkg-types";
+import { parseNodeModulePath } from "mlly";
+import { linkPackage, writePackage } from "./utils";
+const readDirRecursive = async (dir) => {
+  const files = await fse.readdir(dir, {
+    withFileTypes: true
+  });
+  const filesAndDirs = await Promise.all(files.map(async (file) => {
+    const resPath = path.resolve(dir, file.name);
+    return file.isDirectory() ? readDirRecursive(resPath) : resPath;
+  }));
+  return filesAndDirs.flat();
+};
+async function isFile(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) => {
+  const files = await readDirRecursive(rootDir);
+  return files;
+};
+const handleDependencies = async (appDir, serverRootDir, include) => {
+  const base = "/";
+  const entryFiles = await findEntryFiles(serverRootDir);
+  const includeEntries = include.map((item) => {
+    if (isAbsolute(item)) {
+      return item;
+    }
+    try {
+      return require.resolve(item);
+    } catch (error) {
+    }
+    return item;
+  });
+  const _fileTrace = await nodeFileTrace(entryFiles.concat(includeEntries), {
+    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 currentProjectModules = path.join(appDir, "node_modules");
+  const _resolveTracedPath = (p) => fse.realpath(path.resolve(base, p));
+  const tracedFiles = Object.fromEntries(await Promise.all([
+    ..._fileTrace.reasons.entries()
+  ].map(async ([_path, reasons]) => {
+    if (reasons.ignored) {
+      return;
+    }
+    const filePath = await _resolveTracedPath(_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(p)));
+    const tracedFile = {
+      path: filePath,
+      parents,
+      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: [],
+        pkgJSON
+      };
+      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 findPackageParents = (pkg, version) => {
+    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.pkgName === pkg.name) {
+          return null;
+        }
+        return `${parentFile.pkgName}@${parentFile.pkgVersion}`;
+      }).filter(Boolean)))
+    ];
+    return parentPkgs;
+  };
+  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);
+    }
+  }
+  await Promise.all(singleVersionPackages.map((pkgName) => {
+    const pkg = tracedPackages[pkgName];
+    const version = Object.keys(pkg.versions)[0];
+    return writePackage(pkg, version, serverRootDir);
+  }));
+  console.log("multiVersionPkgs111111111", multiVersionPkgs);
+  for (const [pkgName, pkgVersions] of Object.entries(multiVersionPkgs)) {
+    const versionEntires = Object.entries(pkgVersions).sort(
+      // TODO: remove ts-ignore
+      // @ts-expect-error
+      ([v1, p1], [v2, p2]) => {
+        if (p1.length === 0) {
+          return -1;
+        }
+        if (p2.length === 0) {
+          return 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}@${version}`, path.join(serverRootDir, "node_modules")) : linkPackage(pkgDestPath, `${parentPkgName}/node_modules/${pkgName}@${version}`, path.join(serverRootDir, "node_modules")));
+      }
+    }
+  }
+  const projectPkg = await readPackageJSON(serverRootDir).catch(() => ({}));
+  const outputPkgPath = path.join(serverRootDir, "package.json");
+  await fse.writeJSON(outputPkgPath, {
+    name: `${projectPkg.name || "modernjs-project"}-prod`,
+    version: projectPkg.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/entrys/netlify.js

@@ -0,0 +1,71 @@
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import { genPluginImportsCode, getPluginsCode, severAppContextTemplate } from "../utils";
+function genNetlifyEntry({ config, plugins, appContext } = {}) {
+  const defaultConfig = {
+    server: {
+      port: 8080
+    },
+    output: {
+      path: "."
+    }
+  };
+  return `
+
+  const fs = require('node:fs/promises');
+  const path = require('node:path');
+  const { createNetlifyFunction } = require('@modern-js/prod-server/netlify');
+  ${genPluginImportsCode(plugins || [])}
+
+  let requestHandler = null;
+
+  if(!process.env.NODE_ENV){
+    process.env.NODE_ENV = 'production';
+  }
+
+  async function createHandler() {
+    try {
+      let routes = [];
+      const routeFilepath = path.join(__dirname, "${ROUTE_SPEC_FILE}");
+      try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, "utf-8");
+        const routeSpec = JSON.parse(content);
+        routes = routeSpec.routes;
+      } catch (error) {
+        console.warn('route.json not found, continuing with empty routes.');
+      }
+
+      const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        config: ${JSON.stringify(config || defaultConfig)},
+        serverConfigFile: '${DEFAULT_SERVER_CONFIG}',
+        plugins: ${getPluginsCode(plugins || [])},
+        appContext: ${appContext ? severAppContextTemplate(appContext) : "undefined"},
+        disableCustomHook: true
+      }
+
+      requestHandler = await createNetlifyFunction(prodServerOptions)
+
+      return requestHandler
+    } catch(error) {
+      console.error(error);
+      process.exit(1);
+    }
+  }
+
+  createHandler();
+
+  const handleRequest = async(request, context) => {
+    if(typeof requestHandler !== 'function'){
+      await createHandler();
+    }
+    return requestHandler(request, context);
+  }
+
+  export default handleRequest;
+  `;
+}
+export {
+  genNetlifyEntry
+};

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

@@ -0,0 +1,64 @@
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import { genPluginImportsCode, getPluginsCode, severAppContextTemplate } from "../utils";
+function genNodeEntry({ config, plugins, appContext } = {}) {
+  const defaultConfig = {
+    server: {
+      port: 8080
+    },
+    output: {
+      path: "."
+    }
+  };
+  return `
+
+  const fs = require('node:fs/promises');
+  const path = require('node:path');
+  const { createProdServer } = require('@modern-js/prod-server');
+  ${genPluginImportsCode(plugins || [])}
+
+  if(!process.env.NODE_ENV){
+    process.env.NODE_ENV = 'production';
+  }
+
+  async function main() {
+    try {
+      let routes = [];
+      const routeFilepath = path.join(__dirname, "${ROUTE_SPEC_FILE}");
+      try {
+        await fs.access(routeFilepath);
+        const content = await fs.readFile(routeFilepath, "utf-8");
+        const routeSpec = JSON.parse(content);
+        routes = routeSpec.routes;
+      } catch (error) {
+        console.warn('route.json not found, continuing with empty routes.');
+      }
+
+      const prodServerOptions = {
+        pwd: __dirname,
+        routes,
+        config: ${JSON.stringify(config || defaultConfig)},
+        serverConfigFile: '${DEFAULT_SERVER_CONFIG}',
+        plugins: ${getPluginsCode(plugins || [])},
+        appContext: ${appContext ? severAppContextTemplate(appContext) : "undefined"},
+        disableCustomHook: true
+      }
+
+      const app = await createProdServer(prodServerOptions)
+
+      const port = process.env.PORT || 3000;
+
+      app.listen(port, () => {
+        console.log('\\x1b[32mServer is listening on port', port, '\\x1b[0m');
+      });
+    } catch(error) {
+      console.error(error);
+      process.exit(1);
+    }
+  }
+
+  main();
+  `;
+}
+export {
+  genNodeEntry
+};