@nocobase/devtools 2.1.0-beta.15 → 2.1.0-beta.16

package/common.d.ts

@@ -0,0 +1,10 @@
+export declare function getPackagePaths(): [string, string][];
+
+export declare class IndexGenerator {
+  constructor(outputPath: string, pluginsPath: string[]);
+  generate(): void;
+}
+
+export declare function generatePlugins(): void;
+export declare function generateV2Plugins(): void;
+export declare function generateAllPlugins(): void;

package/common.js

@@ -0,0 +1,212 @@
+const { existsSync, mkdirSync, readFileSync, realpathSync, rmSync, writeFileSync } = require('node:fs');
+const { dirname, join, relative, resolve, sep } = require('node:path');
+const glob = require('fast-glob');
+const { resolvePluginStoragePath } = require('@nocobase/utils/plugin-symlink');
+
+function getTsconfigPaths() {
+  const content = readFileSync(resolve(process.cwd(), 'tsconfig.paths.json'), 'utf-8');
+  const json = JSON.parse(content);
+  return json.compilerOptions.paths;
+}
+
+function getPackagePaths() {
+  const paths = getTsconfigPaths();
+  const pkgs = [];
+  for (const key in paths) {
+    if (Object.hasOwnProperty.call(paths, key)) {
+      for (const dir of paths[key]) {
+        if (dir.includes('*')) {
+          const files = glob.sync(dir, { cwd: process.cwd(), onlyDirectories: true });
+          for (const file of files) {
+            const dirname = resolve(process.cwd(), file);
+            if (existsSync(dirname)) {
+              const re = new RegExp(dir.replace('*', '(.+)'));
+              const normalized = dirname
+                .substring(process.cwd().length + 1)
+                .split(sep)
+                .join('/');
+              const match = re.exec(normalized);
+              pkgs.push([key.replace('*', match?.[1]), dirname]);
+            }
+          }
+        } else {
+          const dirname = resolve(process.cwd(), dir);
+          pkgs.push([key, dirname]);
+        }
+      }
+    }
+  }
+  return pkgs;
+}
+
+function getNodeModulesPath(packageDir) {
+  return join(process.cwd(), 'node_modules', packageDir);
+}
+
+class IndexGenerator {
+  nocobaseDir = getNodeModulesPath('@nocobase');
+
+  constructor(outputPath, pluginsPath, options = {}) {
+    this.outputPath = outputPath;
+    this.pluginsPath = pluginsPath;
+    this.options = {
+      clientModuleName: 'client',
+      clientRootFile: 'client.js',
+      clientSourceDir: 'client',
+      ...options,
+    };
+  }
+
+  get indexPath() {
+    return join(this.outputPath, 'index.ts');
+  }
+
+  get packageMapPath() {
+    return join(this.outputPath, 'packageMap.json');
+  }
+
+  get packagesPath() {
+    return join(this.outputPath, 'packages');
+  }
+
+  generate() {
+    this.generatePluginContent();
+  }
+
+  get indexContent() {
+    return `// @ts-nocheck
+import packageMap from './packageMap.json';
+
+function devDynamicImport(packageName: string): Promise<any> {
+  const fileName = packageMap[packageName];
+  if (!fileName) {
+    return Promise.resolve(null);
+  }
+  try {
+    return import(\`./packages/\${fileName}\`)
+  } catch (error) {
+    return Promise.resolve(null);
+  }
+}
+export default devDynamicImport;`;
+  }
+
+  get emptyIndexContent() {
+    return `
+export default function devDynamicImport(packageName: string): Promise<any> {
+  return Promise.resolve(null);
+}`;
+  }
+
+  generatePluginContent() {
+    if (existsSync(this.outputPath)) {
+      rmSync(this.outputPath, { recursive: true, force: true });
+    }
+    mkdirSync(this.outputPath, { recursive: true });
+    const validPluginPaths = this.pluginsPath.filter((pluginsPath) => existsSync(pluginsPath));
+    if (!validPluginPaths.length || process.env.NODE_ENV === 'production') {
+      writeFileSync(this.indexPath, this.emptyIndexContent);
+      return;
+    }
+
+    const pluginInfos = validPluginPaths.map((pluginsPath) => this.getContent(pluginsPath)).flat();
+
+    writeFileSync(this.indexPath, this.indexContent);
+    const packageMapContent = pluginInfos.reduce((memo, item) => {
+      memo[item.packageJsonName] = `${item.pluginFileName}.ts`;
+      return memo;
+    }, {});
+    writeFileSync(this.packageMapPath, JSON.stringify(packageMapContent, null, 2));
+    mkdirSync(this.packagesPath, { recursive: true });
+    pluginInfos.forEach((item) => {
+      const pluginPackagePath = join(this.packagesPath, `${item.pluginFileName}.ts`);
+      writeFileSync(pluginPackagePath, item.exportStatement);
+    });
+  }
+
+  getContent(pluginsPath) {
+    const pluginFolders = glob.sync(['*/package.json', '*/*/package.json'], {
+      cwd: pluginsPath,
+      onlyFiles: true,
+      absolute: true,
+    });
+
+    const storagePluginFolders = glob.sync(['*/package.json', '*/*/package.json'], {
+      cwd: resolvePluginStoragePath(),
+      onlyFiles: true,
+      absolute: true,
+    });
+
+    const nocobasePluginFolders = glob
+      .sync(['plugin-*/package.json'], { cwd: this.nocobaseDir, onlyFiles: true, absolute: true })
+      .map((item) => realpathSync(item));
+
+    return Array.from(new Set([...pluginFolders, ...storagePluginFolders, ...nocobasePluginFolders]))
+      .filter((item) => {
+        const pluginDir = dirname(item);
+        const clientJs = join(pluginDir, this.options.clientRootFile);
+        return existsSync(clientJs);
+      })
+      .map((pluginPackageJsonPath) => {
+        const pluginPackageJson = require(pluginPackageJsonPath);
+        const pluginPathArr = pluginPackageJsonPath.replaceAll(sep, '/').split('/');
+        const hasNamespace = pluginPathArr[pluginPathArr.length - 3].startsWith('@');
+        const pluginFileName = (hasNamespace
+          ? `${pluginPathArr[pluginPathArr.length - 3].replace('@', '')}_${pluginPathArr[pluginPathArr.length - 2]}`
+          : pluginPathArr[pluginPathArr.length - 2]
+        ).replaceAll('-', '_');
+
+        let exportStatement = '';
+        if (pluginPackageJsonPath.includes('packages')) {
+          const pluginSrcClientPath = relative(
+            this.packagesPath,
+            join(dirname(pluginPackageJsonPath), 'src', this.options.clientSourceDir),
+          ).replaceAll(sep, '/');
+          exportStatement = `export { default } from '${pluginSrcClientPath}';`;
+        } else {
+          exportStatement = `export { default } from '${pluginPackageJson.name}/${this.options.clientModuleName}';`;
+        }
+
+        return { exportStatement, pluginFileName, packageJsonName: pluginPackageJson.name };
+      });
+  }
+}
+
+function getPluginDirs() {
+  return (process.env.PLUGIN_PATH || 'packages/plugins/,packages/samples/,packages/pro-plugins/')
+    .split(',')
+    .map((item) => join(process.cwd(), item));
+}
+
+function generatePluginsByOutputPath(outputPluginPath, options = {}) {
+  const pluginDirs = getPluginDirs();
+  const indexGenerator = new IndexGenerator(outputPluginPath, pluginDirs, options);
+  indexGenerator.generate();
+}
+
+function generatePlugins() {
+  generatePluginsByOutputPath(join(process.env.APP_PACKAGE_ROOT, 'client', 'src', '.plugins'));
+}
+
+function generateV2Plugins() {
+  generatePluginsByOutputPath(join(process.env.APP_PACKAGE_ROOT, 'client-v2', 'src', '.plugins'), {
+    clientModuleName: 'client-v2',
+    clientRootFile: 'client-v2.js',
+    clientSourceDir: 'client-v2',
+  });
+}
+
+function generateAllPlugins() {
+  [
+    join(process.env.APP_PACKAGE_ROOT, 'client', 'src', '.plugins'),
+    join(process.env.APP_PACKAGE_ROOT, 'client-v2', 'src', '.plugins'),
+  ].forEach((outputPluginPath) => {
+    generatePluginsByOutputPath(outputPluginPath);
+  });
+}
+
+exports.getPackagePaths = getPackagePaths;
+exports.IndexGenerator = IndexGenerator;
+exports.generatePlugins = generatePlugins;
+exports.generateV2Plugins = generateV2Plugins;
+exports.generateAllPlugins = generateAllPlugins;

package/package.json

@@ -1,13 +1,19 @@
 {
   "name": "@nocobase/devtools",
-  "version": "2.1.0-beta.15",
+  "version": "2.1.0-beta.16",
   "description": "",
   "license": "Apache-2.0",
   "main": "./src/index.js",
   "dependencies": {
-    "@nocobase/build": "2.1.0-beta.15",
-    "@nocobase/client": "2.1.0-beta.15",
-    "@nocobase/test": "2.1.0-beta.15",
+    "@nocobase/build": "2.1.0-beta.16",
+    "@nocobase/client": "2.1.0-beta.16",
+    "@nocobase/test": "2.1.0-beta.16",
+    "@nocobase/utils": "2.1.0-beta.16",
+    "@rsbuild/core": "1.7.3",
+    "@rsbuild/plugin-less": "^1.6.2",
+    "@rsbuild/plugin-node-polyfill": "1.4.4",
+    "@rsbuild/plugin-react": "1.4.6",
+    "@rsbuild/plugin-svgr": "^1.3.1",
     "@types/koa": "^2.15.0",
     "@types/koa-bodyparser": "^4.3.4",
     "@types/lodash": "^4.14.177",
@@ -50,5 +56,5 @@
     "url": "git+https://github.com/nocobase/nocobase.git",
     "directory": "packages/core/devtools"
   },
-  "gitHead": "dc1aceea6357e6ab149976c2a236fc4b6bee1370"
+  "gitHead": "b9a191705a440a336c85d82fd877fdf152bec70f"
 }

package/rsbuildConfig.d.ts

@@ -0,0 +1,3 @@
+export declare function getRsbuildAlias(): Record<string, string>;
+export declare function generatePlugins(): void;
+export declare function generateV2Plugins(): void;

package/rsbuildConfig.js

@@ -0,0 +1,12 @@
+import common from './common.js';
+
+const { getPackagePaths, generateV2Plugins, generatePlugins } = common;
+
+export function getRsbuildAlias() {
+  return getPackagePaths().reduce((memo, item) => {
+    memo[item[0]] = item[1];
+    return memo;
+  }, {});
+}
+
+export { generateV2Plugins, generatePlugins };

package/umiConfig.d.ts

@@ -20,9 +20,4 @@ export declare function getUmiConfig(): {
 };
 
 export declare function resolveNocobasePackagesAlias(config: any): {};
-export declare class IndexGenerator {
-  constructor(outputPath: string, pluginsPath: string[]): void;
-  generate(): void;
-};
-
-export declare function generatePlugins(): {}
+export { IndexGenerator, generateAllPlugins, generatePlugins } from './common.js';

package/umiConfig.js

@@ -1,15 +1,21 @@
-const { existsSync } = require('fs');
-const { resolve, sep } = require('path');
 const packageJson = require('./package.json');
-const fs = require('fs');
-const glob = require('fast-glob');
-const path = require('path');
+const { resolvePublicPath, resolveV2PublicPath } = require('../cli-v1/src/util');
+const { getPackagePaths, IndexGenerator, generatePlugins, generateAllPlugins } = require('./common.js');
 
 console.log('VERSION: ', packageJson.version);
 
 function getUmiConfig() {
-  const { APP_PORT, API_BASE_URL, API_CLIENT_STORAGE_TYPE, API_CLIENT_STORAGE_PREFIX, APP_PUBLIC_PATH } = process.env;
+  const {
+    APP_PORT,
+    APP_V2_PORT,
+    API_BASE_URL,
+    API_CLIENT_STORAGE_TYPE,
+    API_CLIENT_STORAGE_PREFIX,
+    APP_PUBLIC_PATH,
+  } = process.env;
   const API_BASE_PATH = process.env.API_BASE_PATH || '/api/';
+  const normalizedAppPublicPath = resolvePublicPath(APP_PUBLIC_PATH || '/');
+  const V2_PUBLIC_PATH = resolveV2PublicPath(APP_PUBLIC_PATH || '/');
   const PROXY_TARGET_URL = process.env.PROXY_TARGET_URL || `http://127.0.0.1:${APP_PORT}`;
   const LOCAL_STORAGE_BASE_URL = 'storage/uploads/';
   const STATIC_PATH = 'static/';
@@ -20,17 +26,37 @@ function getUmiConfig() {
     }
 
     return {
-      [APP_PUBLIC_PATH + LOCAL_STORAGE_BASE_URL]: {
+      [normalizedAppPublicPath + LOCAL_STORAGE_BASE_URL]: {
         target: PROXY_TARGET_URL,
         changeOrigin: true,
       },
-      [APP_PUBLIC_PATH + STATIC_PATH]: {
+      [normalizedAppPublicPath + STATIC_PATH]: {
         target: PROXY_TARGET_URL,
         changeOrigin: true,
       },
     };
   }
 
+  function getClientV2Proxy() {
+    if (!APP_V2_PORT) {
+      return {};
+    }
+
+    return {
+      [V2_PUBLIC_PATH]: {
+        target: `http://127.0.0.1:${APP_V2_PORT}`,
+        changeOrigin: true,
+        ws: true,
+        pathRewrite: { [`^${V2_PUBLIC_PATH}`]: V2_PUBLIC_PATH },
+        onProxyReq: (proxyReq, req, res) => {
+          if (req?.ip) {
+            proxyReq.setHeader('X-Forwarded-For', req.ip);
+          }
+        },
+      },
+    };
+  }
+
   return {
     alias: getPackagePaths().reduce((memo, item) => {
       memo[item[0]] = item[1];
@@ -72,52 +98,12 @@ function getUmiConfig() {
       },
       // for local storage
       ...getLocalStorageProxy(),
+      // v2 shell dev server proxy
+      ...getClientV2Proxy(),
     },
   };
 }
 
-function getNamespace() {
-  const content = fs.readFileSync(resolve(process.cwd(), 'package.json'), 'utf-8');
-  const json = JSON.parse(content);
-  return json.name;
-}
-
-function getTsconfigPaths() {
-  const content = fs.readFileSync(resolve(process.cwd(), 'tsconfig.paths.json'), 'utf-8');
-  const json = JSON.parse(content);
-  return json.compilerOptions.paths;
-}
-
-function getPackagePaths() {
-  const paths = getTsconfigPaths();
-  const pkgs = [];
-  for (const key in paths) {
-    if (Object.hasOwnProperty.call(paths, key)) {
-      for (let dir of paths[key]) {
-        if (dir.includes('*')) {
-          const files = glob.sync(dir, { cwd: process.cwd(), onlyDirectories: true });
-          for (const file of files) {
-            const dirname = resolve(process.cwd(), file);
-            if (existsSync(dirname)) {
-              const re = new RegExp(dir.replace('*', '(.+)'));
-              const p = dirname
-                .substring(process.cwd().length + 1)
-                .split(sep)
-                .join('/');
-              const match = re.exec(p);
-              pkgs.push([key.replace('*', match?.[1]), dirname]);
-            }
-          }
-        } else {
-          const dirname = resolve(process.cwd(), dir);
-          pkgs.push([key, dirname]);
-        }
-      }
-    }
-  }
-  return pkgs;
-}
-
 function resolveNocobasePackagesAlias(config) {
   const pkgs = getPackagePaths();
   for (const [pkg, dir] of pkgs) {
@@ -126,154 +112,8 @@ function resolveNocobasePackagesAlias(config) {
   }
 }
 
-function getNodeModulesPath(packageDir) {
-  const node_modules_dir = path.join(process.cwd(), 'node_modules');
-  return path.join(node_modules_dir, packageDir);
-}
-class IndexGenerator {
-  nocobaseDir = getNodeModulesPath('@nocobase');
-
-  constructor(outputPath, pluginsPath) {
-    this.outputPath = outputPath;
-    this.pluginsPath = pluginsPath;
-  }
-
-  get indexPath() {
-    return path.join(this.outputPath, 'index.ts');
-  }
-
-  get packageMapPath() {
-    return path.join(this.outputPath, 'packageMap.json');
-  }
-
-  get packagesPath() {
-    return path.join(this.outputPath, 'packages');
-  }
-
-  generate() {
-    this.generatePluginContent();
-    if (process.env.NODE_ENV === 'production') return;
-    // this.pluginsPath.forEach((pluginPath) => {
-    //   if (!fs.existsSync(pluginPath)) {
-    //     return;
-    //   }
-    //   fs.watch(pluginPath, { recursive: false }, () => {
-    //     this.generatePluginContent();
-    //   });
-    // });
-  }
-
-  get indexContent() {
-    return `// @ts-nocheck
-import packageMap from './packageMap.json';
-
-function devDynamicImport(packageName: string): Promise<any> {
-  const fileName = packageMap[packageName];
-  if (!fileName) {
-    return Promise.resolve(null);
-  }
-  try {
-    return import(\`./packages/\${fileName}\`)
-  } catch (error) {
-    return Promise.resolve(null);
-  }
-}
-export default devDynamicImport;`;
-  }
-
-  get emptyIndexContent() {
-    return `
-export default function devDynamicImport(packageName: string): Promise<any> {
-  return Promise.resolve(null);
-}`;
-  }
-
-  generatePluginContent() {
-    if (fs.existsSync(this.outputPath)) {
-      fs.rmSync(this.outputPath, { recursive: true, force: true });
-    }
-    fs.mkdirSync(this.outputPath, { recursive: true, force: true });
-    const validPluginPaths = this.pluginsPath.filter((pluginsPath) => fs.existsSync(pluginsPath));
-    if (!validPluginPaths.length || process.env.NODE_ENV === 'production') {
-      fs.writeFileSync(this.indexPath, this.emptyIndexContent);
-      return;
-    }
-
-    const pluginInfos = validPluginPaths.map((pluginsPath) => this.getContent(pluginsPath)).flat();
-
-    // index.ts
-    fs.writeFileSync(this.indexPath, this.indexContent);
-    // packageMap.json
-    const packageMapContent = pluginInfos.reduce((memo, item) => {
-      memo[item.packageJsonName] = item.pluginFileName + '.ts';
-      return memo;
-    }, {});
-    fs.writeFileSync(this.packageMapPath, JSON.stringify(packageMapContent, null, 2));
-    // packages
-    fs.mkdirSync(this.packagesPath, { recursive: true });
-    pluginInfos.forEach((item) => {
-      const pluginPackagePath = path.join(this.packagesPath, item.pluginFileName + '.ts');
-      fs.writeFileSync(pluginPackagePath, item.exportStatement);
-    });
-  }
-
-  getContent(pluginsPath) {
-    const pluginFolders = glob.sync(['*/package.json', '*/*/package.json'], {
-      cwd: pluginsPath,
-      onlyFiles: true,
-      absolute: true,
-    });
-
-    const storagePluginFolders = glob.sync(['*/package.json', '*/*/package.json'], {
-      cwd: process.env.PLUGIN_STORAGE_PATH,
-      onlyFiles: true,
-      absolute: true,
-    });
-
-    const nocobasePluginFolders = glob
-      .sync(['plugin-*/package.json'], { cwd: this.nocobaseDir, onlyFiles: true, absolute: true })
-      .map((item) => fs.realpathSync(item));
-    const pluginInfos = Array.from(new Set([...pluginFolders, ...storagePluginFolders, ...nocobasePluginFolders]))
-      .filter((item) => {
-        const dirname = path.dirname(item);
-        const clientJs = path.join(dirname, 'client.js');
-        return fs.existsSync(clientJs);
-      })
-      .map((pluginPackageJsonPath) => {
-        const pluginPackageJson = require(pluginPackageJsonPath);
-        const pluginPathArr = pluginPackageJsonPath.replaceAll(path.sep, '/').split('/');
-        const hasNamespace = pluginPathArr[pluginPathArr.length - 3].startsWith('@');
-        const pluginFileName = (hasNamespace
-          ? `${pluginPathArr[pluginPathArr.length - 3].replace('@', '')}_${pluginPathArr[pluginPathArr.length - 2]}`
-          : pluginPathArr[pluginPathArr.length - 2]
-        ).replaceAll('-', '_');
-
-        let exportStatement = '';
-        if (pluginPackageJsonPath.includes('packages')) {
-          const pluginSrcClientPath = path
-            .relative(this.packagesPath, path.join(path.dirname(pluginPackageJsonPath), 'src', 'client'))
-            .replaceAll(path.sep, '/');
-          exportStatement = `export { default } from '${pluginSrcClientPath}';`;
-        } else {
-          exportStatement = `export { default } from '${pluginPackageJson.name}/client';`;
-        }
-        return { exportStatement, pluginFileName, packageJsonName: pluginPackageJson.name };
-      });
-
-    return pluginInfos;
-  }
-}
-
 exports.getUmiConfig = getUmiConfig;
 exports.resolveNocobasePackagesAlias = resolveNocobasePackagesAlias;
 exports.IndexGenerator = IndexGenerator;
-
-exports.generatePlugins = function () {
-  const pluginDirs = (process.env.PLUGIN_PATH || 'packages/plugins/,packages/samples/,packages/pro-plugins/')
-    .split(',')
-    .map((item) => path.join(process.cwd(), item));
-
-  const outputPluginPath = path.join(process.env.APP_PACKAGE_ROOT, 'client', 'src', '.plugins');
-  const indexGenerator = new IndexGenerator(outputPluginPath, pluginDirs);
-  indexGenerator.generate();
-};
+exports.generatePlugins = generatePlugins;
+exports.generateAllPlugins = generateAllPlugins;