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

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

@@ -0,0 +1,71 @@
+import { ROUTE_SPEC_FILE, DEFAULT_SERVER_CONFIG } from "@modern-js/utils";
+import { genPluginImportsCode, getPluginsCode, severAppContextTemplate } from "../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');
+  ${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 {
+  genVercelEntry
+};

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

@@ -0,0 +1,110 @@
+import path from "path";
+import { fs as fse, getInternalPlugins } from "@modern-js/utils";
+import { getProjectUsage } from "./utils";
+import { handleDependencies } from "./dependencies";
+var deploy_default = () => ({
+  name: "@modern-js/plugin-deploy",
+  pre: [
+    "@modern-js/plugin-bff",
+    "@modern-js/plugin-server"
+  ],
+  setup: (api) => {
+    return {
+      async beforeDeploy() {
+        const deployTarget = process.env.MODERNJS_DEPLOY || "node";
+        const appContext = api.useAppContext();
+        const { appDirectory, distDirectory, serverInternalPlugins, sharedDirectory, apiDirectory, lambdaDirectory, metaName } = appContext;
+        const configContext = api.useResolvedConfigContext();
+        const outputDirectory = path.join(appDirectory, ".output");
+        let funcsDirectory = outputDirectory;
+        let staticDirectory = path.join(outputDirectory, "static");
+        await fse.remove(outputDirectory);
+        if (deployTarget === "node") {
+          await fse.copy(distDirectory, outputDirectory, {
+            filter: (src) => {
+              const distStaticDirectory = path.join(distDirectory, "static");
+              return !src.includes(distStaticDirectory);
+            }
+          });
+        }
+        if (deployTarget === "vercel") {
+          funcsDirectory = path.join(outputDirectory, "functions");
+          staticDirectory = path.join(outputDirectory, "static");
+          await fse.copy(distDirectory, funcsDirectory, {
+            filter: (src) => {
+              const distStaticDirectory = path.join(distDirectory, "static");
+              return !src.includes(distStaticDirectory);
+            }
+          });
+          await fse.copy(path.join(distDirectory, "static"), staticDirectory);
+          await fse.writeJSON(path.join(funcsDirectory, ".vc-config.json"), {
+            runtime: "nodejs16.x",
+            handler: "index.js",
+            launcherType: "Nodejs",
+            shouldAddHelpers: false,
+            supportsResponseStreaming: true
+          });
+        }
+        const { bff } = configContext;
+        const config = {
+          output: {
+            path: "."
+          },
+          bff
+        };
+        const plugins = getInternalPlugins(appDirectory, serverInternalPlugins);
+        const serverAppContext = {
+          sharedDirectory: `path.join(__dirname, "${path.relative(appDirectory, sharedDirectory)}")`,
+          apiDirectory: `path.join(__dirname, "${path.relative(appDirectory, apiDirectory)}")`,
+          lambdaDirectory: `path.join(__dirname, "${path.relative(appDirectory, lambdaDirectory)}")`,
+          metaName
+        };
+        let code = ``;
+        console.log("deployTarget111111111", deployTarget);
+        switch (deployTarget) {
+          case "node": {
+            const { genNodeEntry } = await import("./entrys/node");
+            code = genNodeEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          case "vercel": {
+            const { genVercelEntry } = await import("./entrys/vercel");
+            code = genVercelEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          case "netlify": {
+            const { genNetlifyEntry } = await import("./entrys/netlify");
+            code = genNetlifyEntry({
+              plugins,
+              config,
+              appContext: serverAppContext
+            });
+            break;
+          }
+          default: {
+            code = `throw new Error("unknown deploy target, MODERNJS_DEPLOY should be set");`;
+          }
+        }
+        const { useSSR, useAPI, useWebServer } = getProjectUsage(appDirectory, distDirectory);
+        const entryFilePath = path.join(funcsDirectory, "index.js");
+        if (useSSR || useAPI || useWebServer) {
+          await fse.writeFile(entryFilePath, code);
+        }
+        await handleDependencies(appDirectory, funcsDirectory, [
+          "@modern-js/prod-server"
+        ]);
+      }
+    };
+  }
+});
+export {
+  deploy_default as default
+};

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

@@ -0,0 +1,109 @@
+import path from "path";
+import os from "node:os";
+import { ROUTE_SPEC_FILE, fs as fse, isDepExists } from "@modern-js/utils";
+import { parseNodeModulePath } from "mlly";
+const severAppContextTemplate = (serverAppContext) => {
+  return `{
+    sharedDirectory: ${serverAppContext.sharedDirectory},
+    apiDirectory: ${serverAppContext.apiDirectory},
+    lambdaDirectory: ${serverAppContext.lambdaDirectory},
+  }`;
+};
+const getPluginsCode = (plugins) => `[${plugins.map((_, index) => `plugin_${index}()`).join(",")}]`;
+const genPluginImportsCode = (plugins) => {
+  return plugins.map((plugin, index) => `
+      let plugin_${index} = require('${plugin}')
+      plugin_${index} = plugin_${index}.default || plugin_${index}
+      `).join(";\n");
+};
+const getProjectUsage = (appDirectory, distDirectory) => {
+  const routeJSON = path.join(distDirectory, ROUTE_SPEC_FILE);
+  const { routes } = fse.readJSONSync(routeJSON);
+  let useSSR = false;
+  let useAPI = false;
+  routes.forEach((route) => {
+    if (route.isSSR) {
+      useSSR = true;
+    }
+    if (route.isApi) {
+      useAPI = true;
+    }
+  });
+  const useWebServer = isDepExists(appDirectory, "@modern-js/plugin-server");
+  return {
+    useSSR,
+    useAPI,
+    useWebServer
+  };
+};
+function applyProductionCondition(exports) {
+  if (!exports || typeof exports === "string") {
+    return;
+  }
+  if (exports.production) {
+    if (typeof exports.production === "string") {
+      exports.default = exports.production;
+    } else {
+      Object.assign(exports, exports.production);
+    }
+  }
+  for (const key in exports) {
+    applyProductionCondition(exports[key]);
+  }
+}
+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);
+  });
+};
+export {
+  applyProductionCondition,
+  applyPublicCondition,
+  genPluginImportsCode,
+  getPluginsCode,
+  getProjectUsage,
+  linkPackage,
+  severAppContextTemplate,
+  writePackage
+};

package/dist/esm-node/utils/createServer.js

@@ -1,4 +1,5 @@
-import { Server } from "@modern-js/server";
+import { createDevServer } from "@modern-js/server";
+import { initProdMiddlewares } from "@modern-js/prod-server";
 let server = null;
 const getServer = () => server;
 const setServer = (newServer) => {
@@ -6,32 +7,20 @@ const setServer = (newServer) => {
 };
 const closeServer = async () => {
   if (server) {
-    await server.close();
+    server.close();
     server = null;
   }
 };
 const createServer = async (options) => {
   if (server) {
-    await server.close();
+    server.close();
   }
-  server = new Server(options);
-  const app = await server.init();
-  return app;
-};
-const injectDataLoaderPlugin = (internalPlugins) => {
-  const DataLoaderPlugin = require.resolve("@modern-js/plugin-data-loader/server");
-  return {
-    ...internalPlugins,
-    "@modern-js/plugin-data-loader": {
-      path: DataLoaderPlugin,
-      forced: true
-    }
-  };
+  server = await createDevServer(options, initProdMiddlewares);
+  return server;
 };
 export {
   closeServer,
   createServer,
   getServer,
-  injectDataLoaderPlugin,
   setServer
 };

package/dist/esm-node/utils/env.js

@@ -1,4 +1,4 @@
-import { cutNameByHyphen } from "@modern-js/utils";
+import { cutNameByHyphen } from "@modern-js/utils/universal";
 function getAutoInjectEnv(appContext) {
   const { metaName } = appContext;
   const prefix = `${cutNameByHyphen(metaName)}_`.toUpperCase();

package/dist/esm-node/utils/register.js

@@ -0,0 +1,69 @@
+import path from "node:path";
+import { fs, getAliasConfig, readTsConfigByFile } from "@modern-js/utils";
+const registerCompiler = async (appDir = process.cwd(), distDir, alias) => {
+  const TS_CONFIG_FILENAME = `tsconfig.json`;
+  const tsconfigPath = path.resolve(appDir, TS_CONFIG_FILENAME);
+  const isTsProject = await fs.pathExists(tsconfigPath);
+  const aliasConfig = getAliasConfig(alias, {
+    appDirectory: appDir,
+    tsconfigPath
+  });
+  const { paths = {}, absoluteBaseUrl = "./" } = aliasConfig;
+  const tsPaths = Object.keys(paths).reduce((o, key) => {
+    let tsPath = paths[key];
+    if (typeof tsPath === "string" && path.isAbsolute(tsPath)) {
+      tsPath = path.relative(absoluteBaseUrl, tsPath);
+    }
+    if (typeof tsPath === "string") {
+      tsPath = [
+        tsPath
+      ];
+    }
+    return {
+      ...o,
+      [`${key}`]: tsPath
+    };
+  }, {});
+  let tsConfig = {};
+  if (isTsProject) {
+    tsConfig = readTsConfigByFile(tsconfigPath);
+  }
+  try {
+    const tsNode = await import("ts-node");
+    const tsNodeOptions = tsConfig["ts-node"];
+    if (isTsProject) {
+      tsNode.register({
+        project: tsconfigPath,
+        scope: true,
+        // for env.d.ts, https://www.npmjs.com/package/ts-node#missing-types
+        files: true,
+        transpileOnly: true,
+        ignore: [
+          "(?:^|/)node_modules/",
+          `(?:^|/)${distDir}/`
+        ],
+        ...tsNodeOptions
+      });
+    }
+  } catch (error) {
+    const esbuildRegister = await import("esbuild-register/dist/node");
+    esbuildRegister.register({
+      tsconfigRaw: isTsProject ? tsConfig : void 0,
+      hookIgnoreNodeModules: true,
+      hookMatcher: (fileName) => !fileName.startsWith(distDir)
+    });
+  }
+  const tsConfigPaths = await import("@modern-js/utils/tsconfig-paths");
+  if (await fs.pathExists(appDir)) {
+    const loaderRes = tsConfigPaths.loadConfig(appDir);
+    if (loaderRes.resultType === "success") {
+      tsConfigPaths.register({
+        baseUrl: absoluteBaseUrl || "./",
+        paths: tsPaths
+      });
+    }
+  }
+};
+export {
+  registerCompiler
+};

package/dist/types/plugins/deploy/dependencies.d.ts

@@ -0,0 +1 @@
+export declare const handleDependencies: (appDir: string, serverRootDir: string, include: string[]) => Promise<void>;

package/dist/types/plugins/deploy/entrys/netlify.d.ts

@@ -0,0 +1,5 @@
+export declare function genNetlifyEntry({ config, plugins, appContext, }?: {
+    config?: Record<string, any>;
+    plugins?: string[];
+    appContext?: Record<string, any>;
+}): string;

package/dist/types/plugins/deploy/entrys/node.d.ts

@@ -0,0 +1,5 @@
+export declare function genNodeEntry({ config, plugins, appContext, }?: {
+    config?: Record<string, any>;
+    plugins?: string[];
+    appContext?: Record<string, any>;
+}): string;

package/dist/types/plugins/deploy/entrys/vercel.d.ts

@@ -0,0 +1,5 @@
+export declare function genVercelEntry({ config, plugins, appContext, }?: {
+    config?: Record<string, any>;
+    plugins?: string[];
+    appContext?: Record<string, any>;
+}): string;

package/dist/types/plugins/deploy/index.d.ts

@@ -0,0 +1,4 @@
+import { CliPlugin } from '@modern-js/core';
+import { AppTools } from '../../types';
+declare const _default: () => CliPlugin<AppTools>;
+export default _default;

package/dist/types/plugins/deploy/utils.d.ts

@@ -0,0 +1,27 @@
+import type { PackageJson } from 'pkg-types';
+export type ServerAppContext = {
+    sharedDirectory: string;
+    apiDirectory: string;
+    lambdaDirectory: string;
+    metaName: string;
+};
+export declare const severAppContextTemplate: (serverAppContext: ServerAppContext) => string;
+export declare const getPluginsCode: (plugins: string[]) => string;
+export declare const genPluginImportsCode: (plugins: string[]) => string;
+export declare const getProjectUsage: (appDirectory: string, distDirectory: string) => {
+    useSSR: boolean;
+    useAPI: boolean;
+    useWebServer: boolean;
+};
+export declare function applyProductionCondition(exports: PackageJson['exports']): void;
+export declare function applyPublicCondition(pkg: PackageJson): void;
+export type TracedPackage = {
+    name: string;
+    versions: Record<string, {
+        pkgJSON: PackageJson;
+        path: string;
+        files: string[];
+    }>;
+};
+export declare const writePackage: (pkg: TracedPackage, version: string, projectDir: string, _pkgPath?: string) => Promise<void>;
+export declare const linkPackage: (from: string, to: string, projectRootDir: string) => Promise<void>;

package/dist/types/types/config/tools.d.ts

@@ -1,6 +1,6 @@
 import type { JestConfig } from '@modern-js/types';
 import type { PluginSwcOptions } from '@rsbuild/plugin-swc';
-import type { PluginEsbuildOptions } from '@rsbuild/plugin-esbuild';
+import type { PluginEsbuildOptions } from '@modern-js/rsbuild-plugin-esbuild';
 import type { UniBuilderConfig } from '@modern-js/uni-builder';
 import type { UnwrapBuilderConfig, Bundler } from '../utils';
 export type Tailwindcss = Record<string, any> | ((options: Record<string, any>) => Record<string, any> | void);

package/dist/types/utils/createServer.d.ts

@@ -1,12 +1,7 @@
-import { Server, ModernDevServerOptions } from '@modern-js/server';
-import type { InternalPlugins } from '@modern-js/types';
-export declare const getServer: () => Server | null;
+/// <reference types="node" />
+import type { Server } from 'node:http';
+import { ModernDevServerOptions } from '@modern-js/server';
+export declare const getServer: () => Server<typeof import("http").IncomingMessage, typeof import("http").ServerResponse> | null;
 export declare const setServer: (newServer: Server) => void;
 export declare const closeServer: () => Promise<void>;
 export declare const createServer: (options: ModernDevServerOptions) => Promise<Server>;
-export declare const injectDataLoaderPlugin: (internalPlugins: InternalPlugins) => {
-    '@modern-js/plugin-data-loader': {
-        path: string;
-        forced: boolean;
-    };
-};

package/dist/types/utils/register.d.ts

@@ -0,0 +1,3 @@
+import { Alias } from '@modern-js/utils';
+import { ChainedConfig } from '@rsbuild/shared';
+export declare const registerCompiler: (appDir: string | undefined, distDir: string, alias?: ChainedConfig<Alias>) => Promise<void>;

package/package.json

@@ -15,7 +15,7 @@
     "modern",
     "modern.js"
   ],
-  "version": "2.48.6",
+  "version": "2.49.1-alpha.0",
   "jsnext:source": "./src/index.ts",
   "types": "./dist/types/index.d.ts",
   "main": "./dist/cjs/index.js",
@@ -69,37 +69,43 @@
     "@babel/parser": "^7.22.15",
     "@babel/traverse": "^7.23.2",
     "@babel/types": "^7.23.0",
-    "@rsbuild/plugin-esbuild": "0.6.1",
-    "@rsbuild/plugin-node-polyfill": "0.6.1",
-    "@rsbuild/shared": "0.6.1",
-    "@rsbuild/core": "0.6.1",
+    "@rsbuild/core": "0.6.4",
+    "@rsbuild/plugin-node-polyfill": "0.6.4",
+    "@rsbuild/shared": "0.6.4",
+    "@swc/helpers": "0.5.3",
+    "@vercel/nft": "^0.26.4",
     "es-module-lexer": "^1.1.0",
     "esbuild": "0.17.19",
-    "@swc/helpers": "0.5.3",
-    "@modern-js/core": "2.48.6",
-    "@modern-js/uni-builder": "2.48.6",
-    "@modern-js/node-bundle-require": "2.48.6",
-    "@modern-js/plugin-data-loader": "2.48.6",
-    "@modern-js/plugin": "2.48.6",
-    "@modern-js/plugin-i18n": "2.48.6",
-    "@modern-js/prod-server": "2.48.6",
-    "@modern-js/plugin-lint": "2.48.6",
-    "@modern-js/server": "2.48.6",
-    "@modern-js/server-utils": "2.48.6",
-    "@modern-js/types": "2.48.6",
-    "@modern-js/server-core": "2.48.6",
-    "@modern-js/utils": "2.48.6"
+    "esbuild-register": "^3.5.0",
+    "mlly": "^1.6.1",
+    "pkg-types": "^1.1.0",
+    "@modern-js/core": "2.49.0",
+    "@modern-js/node-bundle-require": "2.49.0",
+    "@modern-js/plugin": "2.49.0",
+    "@modern-js/plugin-i18n": "2.49.0",
+    "@modern-js/plugin-lint": "2.49.0",
+    "@modern-js/prod-server": "2.49.0",
+    "@modern-js/rsbuild-plugin-esbuild": "0.6.3",
+    "@modern-js/server": "2.49.0",
+    "@modern-js/plugin-data-loader": "2.49.0",
+    "@modern-js/server-utils": "2.49.0",
+    "@modern-js/server-core": "2.49.0",
+    "@modern-js/types": "2.49.0",
+    "@modern-js/uni-builder": "2.49.0",
+    "@modern-js/utils": "2.49.0"
   },
   "devDependencies": {
-    "@rsbuild/plugin-swc": "0.6.1",
+    "@rsbuild/plugin-swc": "0.6.4",
     "@types/babel__traverse": "7.18.5",
     "@types/jest": "^29",
     "@types/node": "^14",
     "jest": "^29",
+    "ts-node": "^10.9.1",
+    "tsconfig-paths": "^4.2.0",
     "typescript": "^5",
     "webpack": "^5.91.0",
-    "@scripts/build": "2.48.6",
-    "@scripts/jest-config": "2.48.6"
+    "@scripts/build": "2.49.0",
+    "@scripts/jest-config": "2.49.0"
   },
   "sideEffects": false,
   "publishConfig": {