@nocobase/utils 1.9.32 → 1.9.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/utils",
-  "version": "1.9.32",
+  "version": "1.9.34",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "AGPL-3.0",
@@ -11,10 +11,11 @@
     "dayjs": "^1.11.9",
     "deepmerge": "^4.2.2",
     "flat-to-nested": "^1.1.1",
+    "fs-extra": "^11.1.1",
     "graphlib": "^2.1.8",
     "handlebars": "^4.7.8",
     "multer": "^1.4.5-lts.2",
     "object-path": "^0.11.8"
   },
-  "gitHead": "40b6cf8117d8ae2435fead40d26d12647706f852"
+  "gitHead": "8779a68face5b8f159aef726f73695f319ab7659"
 }

package/plugin-symlink.js

@@ -1,114 +1,176 @@
-const { dirname, resolve } = require('path');
-const { realpath, readFile, writeFile, readdir, symlink, unlink, mkdir, stat } = require('fs').promises;
+const { resolve } = require('path');
+const fs = require('fs-extra');
 
+/**
+ * Recursively get plugin names from a directory
+ * @param {string} target - Target directory to scan
+ * @returns {Promise<string[]>} Array of plugin names
+ */
 async function getStoragePluginNames(target) {
   const plugins = [];
-  const items = await readdir(target);
+  const items = await fs.readdir(target);
+
   for (const item of items) {
+    const itemPath = resolve(target, item);
+
     if (item.startsWith('@')) {
-      const dirPath = resolve(target, item);
-      const s = await stat(dirPath);
-      if (!s.isDirectory()) {
+      const statResult = await fs.stat(itemPath);
+      if (!statResult.isDirectory()) {
         continue;
       }
-      const children = await getStoragePluginNames(dirPath);
-      plugins.push(
-        ...children.map((child) => {
-          return `${item}/${child}`;
-        }),
-      );
-    } else if (await fsExists(resolve(target, item, 'package.json'))) {
+      const children = await getStoragePluginNames(itemPath);
+      plugins.push(...children.map((child) => `${item}/${child}`));
+    } else if (await fs.pathExists(resolve(itemPath, 'package.json'))) {
       plugins.push(item);
     }
   }
+
   return plugins;
 }
 
-async function fsExists(path) {
+/**
+ * Ensure the organization directory exists for scoped packages
+ * @param {string} nodeModulesPath - Path to node_modules
+ * @param {string} pluginName - Plugin name (may be scoped)
+ * @returns {Promise<void>}
+ */
+async function ensureOrgDirectory(nodeModulesPath, pluginName) {
+  if (pluginName.startsWith('@')) {
+    const [orgName] = pluginName.split('/');
+    const orgPath = resolve(nodeModulesPath, orgName);
+    await fs.ensureDir(orgPath);
+  }
+}
+
+/**
+ * Check if a symlink already points to the correct target
+ * @param {string} linkPath - Path to the symlink
+ * @param {string} targetPath - Expected target path
+ * @returns {Promise<boolean>} True if symlink exists and points to target
+ */
+async function isSymlinkValid(linkPath, targetPath) {
   try {
-    await stat(path);
-    return true;
+    if (await fs.pathExists(linkPath)) {
+      const realPath = await fs.realpath(linkPath);
+      return realPath === targetPath;
+    }
   } catch (error) {
+    // If realpath fails, the symlink is invalid
     return false;
   }
+  return false;
 }
 
-exports.fsExists = fsExists;
-
-async function createStoragePluginSymLink(pluginName) {
-  const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
-  const nodeModulesPath = process.env.NODE_MODULES_PATH; // resolve(dirname(require.resolve('@nocobase/server/package.json')), 'node_modules');
-  // const nodeModulesPath = resolve(process.cwd(), 'node_modules');
+/**
+ * Remove an existing symlink or file at the given path
+ * @param {string} linkPath - Path to remove
+ * @param {string} pluginName - Plugin name for error messages
+ * @param {string} pluginType - Type of plugin ('storage' or 'dev') for error messages
+ * @returns {Promise<void>}
+ */
+async function removeExistingLink(linkPath, pluginName, pluginType) {
   try {
-    if (pluginName.startsWith('@')) {
-      const [orgName] = pluginName.split('/');
-      if (!(await fsExists(resolve(nodeModulesPath, orgName)))) {
-        await mkdir(resolve(nodeModulesPath, orgName), { recursive: true });
-      }
+    await fs.remove(linkPath);
+  } catch (error) {
+    // Ignore ENOENT errors (file doesn't exist)
+    if (error.code !== 'ENOENT') {
+      console.error(`Failed to remove existing symlink for ${pluginType} plugin: ${pluginName}`, error.message);
     }
-    const link = resolve(nodeModulesPath, pluginName);
-    if (await fsExists(link)) {
-      const realPath = await realpath(link);
-      if (realPath !== resolve(storagePluginsPath, pluginName)) {
-        return;
-      }
+  }
+}
+
+/**
+ * Create a symlink for a plugin
+ * @param {string} pluginName - Name of the plugin
+ * @param {string} sourcePath - Source directory path
+ * @param {string} nodeModulesPath - Target node_modules path
+ * @param {string} pluginType - Type of plugin ('storage' or 'dev')
+ * @returns {Promise<void>}
+ */
+async function createPluginSymLink(pluginName, sourcePath, nodeModulesPath, pluginType) {
+  if (!nodeModulesPath) {
+    console.error(`NODE_MODULES_PATH is not set, cannot create symlink for ${pluginType} plugin: ${pluginName}`);
+    return;
+  }
+
+  try {
+    const targetPath = resolve(sourcePath, pluginName);
+
+    // Check if source exists
+    if (!(await fs.pathExists(targetPath))) {
+      console.warn(`Source path does not exist for ${pluginType} plugin: ${pluginName} at ${targetPath}`);
+      return;
     }
-    try {
-      await unlink(link);
-    } catch (error) {
-      console.error(`Failed to remove existing symlink for storage plugin: ${pluginName}`);
+
+    // Ensure organization directory exists for scoped packages
+    await ensureOrgDirectory(nodeModulesPath, pluginName);
+
+    const linkPath = resolve(nodeModulesPath, pluginName);
+
+    // Check if symlink already points to the correct target
+    if (await isSymlinkValid(linkPath, targetPath)) {
+      return; // Symlink is already correct, no need to recreate
     }
-    await symlink(resolve(storagePluginsPath, pluginName), link, 'dir');
-    // console.log(`Created symlink for storage plugin: ${pluginName}`);
+
+    // Remove existing link if it exists
+    await removeExistingLink(linkPath, pluginName, pluginType);
+
+    // Create new symlink
+    await fs.symlink(targetPath, linkPath, 'dir');
   } catch (error) {
-    console.error(`Failed to create symlink for storage plugin: ${pluginName}`);
+    console.error(`Failed to create symlink for ${pluginType} plugin: ${pluginName}`, error.message);
   }
 }
 
-exports.createStoragePluginSymLink = createStoragePluginSymLink;
+/**
+ * Create a symlink for a storage plugin
+ * @param {string} pluginName - Name of the plugin
+ * @returns {Promise<void>}
+ */
+async function createStoragePluginSymLink(pluginName) {
+  const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
+  const nodeModulesPath = process.env.NODE_MODULES_PATH;
+  await createPluginSymLink(pluginName, storagePluginsPath, nodeModulesPath, 'storage');
+}
 
+/**
+ * Create symlinks for all storage plugins
+ * @returns {Promise<void>}
+ */
 async function createStoragePluginsSymlink() {
   const storagePluginsPath = resolve(process.cwd(), 'storage/plugins');
-  if (!(await fsExists(storagePluginsPath))) {
+  if (!(await fs.pathExists(storagePluginsPath))) {
     return;
   }
   const pluginNames = await getStoragePluginNames(storagePluginsPath);
   await Promise.all(pluginNames.map((pluginName) => createStoragePluginSymLink(pluginName)));
 }
 
-exports.createStoragePluginsSymlink = createStoragePluginsSymlink;
-
+/**
+ * Create a symlink for a dev plugin
+ * @param {string} pluginName - Name of the plugin
+ * @returns {Promise<void>}
+ */
 async function createDevPluginSymLink(pluginName) {
   const packagePluginsPath = resolve(process.cwd(), 'packages/plugins');
-  const nodeModulesPath = process.env.NODE_MODULES_PATH; // resolve(dirname(require.resolve('@nocobase/server/package.json')), 'node_modules');
-  try {
-    if (pluginName.startsWith('@')) {
-      const [orgName] = pluginName.split('/');
-      if (!(await fsExists(resolve(nodeModulesPath, orgName)))) {
-        await mkdir(resolve(nodeModulesPath, orgName), { recursive: true });
-      }
-    }
-    const link = resolve(nodeModulesPath, pluginName);
-    try {
-      await unlink(link);
-    } catch (error) {
-      console.error(`Failed to remove existing symlink for dev plugin: ${pluginName}`);
-    }
-    await symlink(resolve(packagePluginsPath, pluginName), link, 'dir');
-  } catch (error) {
-    console.error(`Failed to create symlink for dev plugin: ${pluginName}`);
-  }
+  const nodeModulesPath = process.env.NODE_MODULES_PATH;
+  await createPluginSymLink(pluginName, packagePluginsPath, nodeModulesPath, 'dev');
 }
 
-exports.createDevPluginSymLink = createDevPluginSymLink;
-
+/**
+ * Create symlinks for all dev plugins
+ * @returns {Promise<void>}
+ */
 async function createDevPluginsSymlink() {
-  const storagePluginsPath = resolve(process.cwd(), 'packages/plugins');
-  if (!(await fsExists(storagePluginsPath))) {
+  const packagePluginsPath = resolve(process.cwd(), 'packages/plugins');
+  if (!(await fs.pathExists(packagePluginsPath))) {
     return;
   }
-  const pluginNames = await getStoragePluginNames(storagePluginsPath);
+  const pluginNames = await getStoragePluginNames(packagePluginsPath);
   await Promise.all(pluginNames.map((pluginName) => createDevPluginSymLink(pluginName)));
 }
 
+exports.createStoragePluginSymLink = createStoragePluginSymLink;
+exports.createStoragePluginsSymlink = createStoragePluginsSymlink;
+exports.createDevPluginSymLink = createDevPluginSymLink;
 exports.createDevPluginsSymlink = createDevPluginsSymlink;