@nocobase/utils 2.1.0-alpha.32 → 2.1.0-alpha.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nocobase/utils",
-  "version": "2.1.0-alpha.32",
+  "version": "2.1.0-alpha.34",
   "main": "lib/index.js",
   "types": "./lib/index.d.ts",
   "license": "Apache-2.0",
@@ -21,5 +21,5 @@
     "object-path": "^0.11.8",
     "ses": "^1.14.0"
   },
-  "gitHead": "1ba7d717e156651db17c615f9b9c48edd669d19b"
+  "gitHead": "59970f73bdbea2656e20cd24357bacf78a3f759f"
 }

package/plugin-symlink.d.ts

@@ -4,3 +4,4 @@ export declare function createStoragePluginSymLink(pluginName: any): Promise<voi
 export declare function createStoragePluginsSymlink(): Promise<void>;
 export declare function createDevPluginSymLink(pluginName: any): Promise<void>;
 export declare function createDevPluginsSymlink(): Promise<void>;
+export declare function syncPluginSymlinks(): Promise<void>;

package/plugin-symlink.js

@@ -37,6 +37,36 @@ async function getStoragePluginNames(target) {
   return plugins;
 }
 
+async function getPluginNamesFromSourceRoot(rootPath) {
+  if (!(await fs.pathExists(rootPath))) {
+    return [];
+  }
+  return await getStoragePluginNames(rootPath);
+}
+
+async function isValidPluginSourcePath(candidate) {
+  return await fs.pathExists(resolve(candidate, 'package.json'));
+}
+
+function getPluginSourceRoots(storagePluginsPath) {
+  return [
+    resolve(process.cwd(), 'packages/plugins'),
+    resolve(process.cwd(), 'packages/pro-plugins'),
+    storagePluginsPath,
+  ];
+}
+
+async function resolvePluginSourcePath(pluginName, storagePluginsPath) {
+  const sourceRoots = getPluginSourceRoots(storagePluginsPath);
+  for (const rootPath of sourceRoots) {
+    const candidate = resolve(rootPath, pluginName);
+    if (await isValidPluginSourcePath(candidate)) {
+      return candidate;
+    }
+  }
+  return '';
+}
+
 /**
  * Ensure the organization directory exists for scoped packages
  * @param {string} nodeModulesPath - Path to node_modules
@@ -52,22 +82,35 @@ async function ensureOrgDirectory(nodeModulesPath, pluginName) {
 }
 
 /**
- * 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
+ * Check whether node_modules entry is a real directory, symlink, or missing
+ * @param {string} linkPath - Path inside node_modules
+ * @returns {Promise<'missing'|'dir'|'symlink'|'other'>}
  */
-async function isSymlinkValid(linkPath, targetPath) {
+async function getNodeModulesEntryType(linkPath) {
   try {
-    if (await fs.pathExists(linkPath)) {
-      const realPath = await fs.realpath(linkPath);
-      return realPath === targetPath;
+    const statResult = await fs.lstat(linkPath);
+    if (statResult.isSymbolicLink()) {
+      return 'symlink';
     }
+    if (statResult.isDirectory()) {
+      return 'dir';
+    }
+    return 'other';
   } catch (error) {
-    // If realpath fails, the symlink is invalid
+    if (error.code === 'ENOENT') {
+      return 'missing';
+    }
+    return 'other';
+  }
+}
+
+async function isSymlinkValid(linkPath, targetPath) {
+  try {
+    const realPath = await fs.realpath(linkPath);
+    return realPath === targetPath;
+  } catch {
     return false;
   }
-  return false;
 }
 
 /**
@@ -119,13 +162,18 @@ async function createPluginSymLink(pluginName, sourcePath, nodeModulesPath, plug
       return;
     }
 
+    const linkPath = resolve(nodeModulesPath, pluginName);
+    const entryType = await getNodeModulesEntryType(linkPath);
+
+    if (entryType === 'dir') {
+      return;
+    }
+
     // 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)) {
+    if (entryType === 'symlink' && (await isSymlinkValid(linkPath, targetPath))) {
       return; // Symlink is already correct, no need to recreate
     }
 
@@ -142,7 +190,6 @@ async function createPluginSymLink(pluginName, sourcePath, nodeModulesPath, plug
 /**
  * Create a symlink for a storage plugin
  * @param {string} pluginName - Name of the plugin
- * @returns {Promise<void>}
  */
 async function createStoragePluginSymLink(pluginName) {
   const storagePluginsPath = resolvePluginStoragePath();
@@ -187,8 +234,56 @@ async function createDevPluginsSymlink() {
   await Promise.all(pluginNames.map((pluginName) => createDevPluginSymLink(pluginName)));
 }
 
+/**
+ * Create symlinks for all plugins from all sources
+ * @returns {Promise<void>}
+ */
+async function syncPluginSymlinks() {
+  const nodeModulesPath = process.env.NODE_MODULES_PATH;
+  if (!nodeModulesPath) {
+    return;
+  }
+
+  const storagePluginsPath = resolvePluginStoragePath();
+  const sourceRoots = getPluginSourceRoots(storagePluginsPath);
+  const pluginNames = new Set();
+
+  for (const rootPath of sourceRoots) {
+    const names = await getPluginNamesFromSourceRoot(rootPath);
+    names.forEach((name) => pluginNames.add(name));
+  }
+
+  await Promise.all(
+    [...pluginNames].map(async (pluginName) => {
+      const linkPath = resolve(nodeModulesPath, pluginName);
+      const entryType = await getNodeModulesEntryType(linkPath);
+
+      if (entryType === 'dir') {
+        return;
+      }
+
+      const sourcePath = await resolvePluginSourcePath(pluginName, storagePluginsPath);
+      if (!sourcePath) {
+        if (entryType === 'symlink' || entryType === 'other') {
+          await removeExistingLink(linkPath, pluginName, 'plugin');
+        }
+        return;
+      }
+
+      if (entryType === 'symlink' && (await isSymlinkValid(linkPath, sourcePath))) {
+        return;
+      }
+
+      await ensureOrgDirectory(nodeModulesPath, pluginName);
+      await removeExistingLink(linkPath, pluginName, 'plugin');
+      await fs.symlink(sourcePath, linkPath, 'dir');
+    }),
+  );
+}
+
 exports.resolvePluginStoragePath = resolvePluginStoragePath;
 exports.createStoragePluginSymLink = createStoragePluginSymLink;
 exports.createStoragePluginsSymlink = createStoragePluginsSymlink;
 exports.createDevPluginSymLink = createDevPluginSymLink;
 exports.createDevPluginsSymlink = createDevPluginsSymlink;
+exports.syncPluginSymlinks = syncPluginSymlinks;