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

package/dist/cjs/builder/builder-webpack/index.js

@@ -38,7 +38,7 @@ async function createWebpackBuilderForModern(options) {
   const { normalizedConfig } = options;
   if (normalizedConfig.tools.esbuild) {
     const { esbuild: esbuildOptions } = normalizedConfig.tools;
-    const { pluginEsbuild } = await Promise.resolve().then(() => __toESM(require("@rsbuild/plugin-esbuild")));
+    const { pluginEsbuild } = await Promise.resolve().then(() => __toESM(require("@modern-js/rsbuild-plugin-esbuild")));
     builder.addPlugins([
       pluginEsbuild(esbuildOptions)
     ]);

package/dist/cjs/index.js

@@ -47,6 +47,7 @@ var import_initialize = __toESM(require("./initialize"));
 var import_hooks = require("./hooks");
 var import_locale = require("./locale");
 var import_serverBuild = __toESM(require("./plugins/serverBuild"));
+var import_deploy = __toESM(require("./plugins/deploy"));
 var import_restart = require("./utils/restart");
 var import_generateWatchFiles = require("./utils/generateWatchFiles");
 var import_core = require("@modern-js/core");
@@ -120,7 +121,8 @@ const appTools = (options = {
       bundler: (options === null || options === void 0 ? void 0 : options.bundler) === "experimental-rspack" ? "rspack" : "webpack"
     }),
     (0, import_serverBuild.default)(),
-    (0, import_plugin_lint.lintPlugin)()
+    (0, import_plugin_lint.lintPlugin)(),
+    (0, import_deploy.default)()
   ],
   setup: (api) => {
     const appContext = api.useAppContext();

package/dist/cjs/plugins/deploy/dependencies.js

@@ -0,0 +1,257 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var dependencies_exports = {};
+__export(dependencies_exports, {
+  handleDependencies: () => handleDependencies
+});
+module.exports = __toCommonJS(dependencies_exports);
+var import_node_path = __toESM(require("node:path"));
+var import_nft = require("@vercel/nft");
+var import_utils = require("@modern-js/utils");
+var import_pkg_types = require("pkg-types");
+var import_mlly = require("mlly");
+var import_utils2 = require("./utils");
+const readDirRecursive = async (dir) => {
+  const files = await import_utils.fs.readdir(dir, {
+    withFileTypes: true
+  });
+  const filesAndDirs = await Promise.all(files.map(async (file) => {
+    const resPath = import_node_path.default.resolve(dir, file.name);
+    return file.isDirectory() ? readDirRecursive(resPath) : resPath;
+  }));
+  return filesAndDirs.flat();
+};
+async function isFile(file) {
+  try {
+    const stat = await import_utils.fs.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 ((0, import_node_path.isAbsolute)(item)) {
+      return item;
+    }
+    try {
+      return require.resolve(item);
+    } catch (error) {
+    }
+    return item;
+  });
+  const _fileTrace = await (0, import_nft.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 (0, import_nft.resolve)(id, parent, job, isCjs);
+      }
+    }
+  });
+  const currentProjectModules = import_node_path.default.join(appDir, "node_modules");
+  const _resolveTracedPath = (p) => import_utils.fs.realpath(import_node_path.default.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 = (0, import_mlly.parseNodeModulePath)(filePath);
+      baseDir = parsed.dir;
+      pkgName = parsed.name;
+      subpath = parsed.subpath;
+      pkgPath = import_node_path.default.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 ? import_node_path.default.join(match[0], "package.json") : await (0, import_utils.pkgUp)({
+        cwd: import_node_path.default.dirname(filePath)
+      });
+      if (packageJsonPath) {
+        const packageJson = await import_utils.fs.readJSON(packageJsonPath);
+        pkgPath = baseDir = import_node_path.default.dirname(packageJsonPath);
+        subpath = import_node_path.default.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 (0, import_pkg_types.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 (0, import_utils2.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 (0, import_utils2.writePackage)(pkg, version, serverRootDir, pkgDestPath);
+      await (0, import_utils2.linkPackage)(pkgDestPath, `${pkgName}`, serverRootDir);
+      for (const parentPkg of parentPkgs) {
+        const parentPkgName = parentPkg.replace(/@[^@]+$/, "");
+        await (multiVersionPkgs[parentPkgName] ? (0, import_utils2.linkPackage)(pkgDestPath, `.modernjs/${parentPkg}/node_modules/${pkgName}@${version}`, import_node_path.default.join(serverRootDir, "node_modules")) : (0, import_utils2.linkPackage)(pkgDestPath, `${parentPkgName}/node_modules/${pkgName}@${version}`, import_node_path.default.join(serverRootDir, "node_modules")));
+      }
+    }
+  }
+  const projectPkg = await (0, import_pkg_types.readPackageJSON)(serverRootDir).catch(() => ({}));
+  const outputPkgPath = import_node_path.default.join(serverRootDir, "package.json");
+  await import_utils.fs.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)))
+  });
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  handleDependencies
+});

package/dist/cjs/plugins/deploy/entrys/netlify.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var netlify_exports = {};
+__export(netlify_exports, {
+  genNetlifyEntry: () => genNetlifyEntry
+});
+module.exports = __toCommonJS(netlify_exports);
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../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');
+  ${(0, import_utils2.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, "${import_utils.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: '${import_utils.DEFAULT_SERVER_CONFIG}',
+        plugins: ${(0, import_utils2.getPluginsCode)(plugins || [])},
+        appContext: ${appContext ? (0, import_utils2.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;
+  `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genNetlifyEntry
+});

package/dist/cjs/plugins/deploy/entrys/node.js

@@ -0,0 +1,88 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var node_exports = {};
+__export(node_exports, {
+  genNodeEntry: () => genNodeEntry
+});
+module.exports = __toCommonJS(node_exports);
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../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');
+  ${(0, import_utils2.genPluginImportsCode)(plugins || [])}
+
+  if(!process.env.NODE_ENV){
+    process.env.NODE_ENV = 'production';
+  }
+
+  async function main() {
+    try {
+      let routes = [];
+      const routeFilepath = path.join(__dirname, "${import_utils.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: '${import_utils.DEFAULT_SERVER_CONFIG}',
+        plugins: ${(0, import_utils2.getPluginsCode)(plugins || [])},
+        appContext: ${appContext ? (0, import_utils2.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();
+  `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genNodeEntry
+});

package/dist/cjs/plugins/deploy/entrys/vercel.js

@@ -0,0 +1,95 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var vercel_exports = {};
+__export(vercel_exports, {
+  genVercelEntry: () => genVercelEntry
+});
+module.exports = __toCommonJS(vercel_exports);
+var import_utils = require("@modern-js/utils");
+var import_utils2 = require("../utils");
+function genVercelEntry({ 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');
+  ${(0, import_utils2.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, "${import_utils.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: '${import_utils.DEFAULT_SERVER_CONFIG}',
+        plugins: ${(0, import_utils2.getPluginsCode)(plugins || [])},
+        appContext: ${appContext ? (0, import_utils2.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;
+  `;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  genVercelEntry
+});