fix(core): avoid launching default plugins twice

packages/nx/src/project-graph/plugins/get-plugins.ts

@@ -1,6 +1,10 @@
 import { hashObject } from '../../hasher/file-hasher';
 import { readNxJson } from '../../config/nx-json';
-import { LoadedNxPlugin, loadNxPlugins } from './internal-api';
+import {
+  loadDefaultNxPlugins,
+  LoadedNxPlugin,
+  loadSpecifiedNxPlugins,
+} from './internal-api';
 import { workspaceRoot } from '../../utils/workspace-root';
 
 let currentPluginsConfigurationHash: string;
@@ -10,7 +14,7 @@ let pendingPluginsPromise:
   | undefined;
 let cleanup: () => void;
 
-export async function getPlugins() {
+export async function getPlugins(): Promise<LoadedNxPlugin[]> {
   const pluginsConfiguration = readNxJson().plugins ?? [];
   const pluginsConfigurationHash = hashObject(pluginsConfiguration);
 
@@ -28,13 +32,19 @@ export async function getPlugins() {
     cleanup();
   }
 
-  pendingPluginsPromise ??= loadNxPlugins(pluginsConfiguration, workspaceRoot);
+  pendingPluginsPromise ??= loadSpecifiedNxPlugins(
+    pluginsConfiguration,
+    workspaceRoot
+  );
 
   currentPluginsConfigurationHash = pluginsConfigurationHash;
-  const [result, cleanupFn] = await pendingPluginsPromise;
+  const [[result, cleanupFn], defaultPlugins] = await Promise.all([
+    pendingPluginsPromise,
+    getOnlyDefaultPlugins(),
+  ]);
   cleanup = cleanupFn;
-  loadedPlugins = result;
-  return result;
+  loadedPlugins = result.concat(defaultPlugins);
+  return loadedPlugins;
 }
 
 let loadedDefaultPlugins: LoadedNxPlugin[];
@@ -55,7 +65,7 @@ export async function getOnlyDefaultPlugins() {
     cleanupDefaultPlugins();
   }
 
-  pendingDefaultPluginPromise ??= loadNxPlugins([], workspaceRoot);
+  pendingDefaultPluginPromise ??= loadDefaultNxPlugins(workspaceRoot);
 
   const [result, cleanupFn] = await pendingDefaultPluginPromise;
   cleanupDefaultPlugins = cleanupFn;

packages/nx/src/project-graph/plugins/internal-api.ts

@@ -145,15 +145,67 @@ function isIsolationEnabled() {
   return true;
 }
 
+const loadingMethod = isIsolationEnabled()
+  ? loadNxPluginInIsolation
+  : loadNxPlugin;
+
 /**
- * Use `getPlugins` instead.
- * @deprecated Do not use this. Use `getPlugins` instead.
+ * @deprecated prefer getOnlyDefaultPlugins
  */
-export async function loadNxPlugins(
+export async function loadDefaultNxPlugins(root = workspaceRoot) {
+  performance.mark('loadDefaultNxPlugins:start');
+
+  const plugins = await getDefaultPlugins(root);
+
+  const cleanupFunctions: Array<() => void> = [];
+  const ret = [
+    await Promise.all(
+      plugins.map(async (plugin) => {
+        performance.mark(`Load Nx Plugin: ${plugin} - start`);
+
+        const [loadedPluginPromise, cleanup] = await loadingMethod(
+          plugin,
+          root
+        );
+
+        cleanupFunctions.push(cleanup);
+        const res = await loadedPluginPromise;
+        performance.mark(`Load Nx Plugin: ${plugin} - end`);
+        performance.measure(
+          `Load Nx Plugin: ${plugin}`,
+          `Load Nx Plugin: ${plugin} - start`,
+          `Load Nx Plugin: ${plugin} - end`
+        );
+
+        return res;
+      })
+    ),
+    () => {
+      for (const fn of cleanupFunctions) {
+        fn();
+      }
+      if (unregisterPluginTSTranspiler) {
+        unregisterPluginTSTranspiler();
+      }
+    },
+  ] as const;
+  performance.mark('loadDefaultNxPlugins:end');
+  performance.measure(
+    'loadDefaultNxPlugins',
+    'loadDefaultNxPlugins:start',
+    'loadDefaultNxPlugins:end'
+  );
+  return ret;
+}
+
+/**
+ * @deprecated prefer getPlugins
+ */
+export async function loadSpecifiedNxPlugins(
   plugins: PluginConfiguration[],
   root = workspaceRoot
 ): Promise<readonly [LoadedNxPlugin[], () => void]> {
-  performance.mark('loadNxPlugins:start');
+  performance.mark('loadSpecifiedNxPlugins:start');
   const loadingMethod = isIsolationEnabled()
     ? loadNxPluginInIsolation
     : loadNxPlugin;
@@ -193,23 +245,38 @@ export async function loadNxPlugins(
       }
     },
   ] as const;
-  performance.mark('loadNxPlugins:end');
+  performance.mark('loadSpecifiedNxPlugins:end');
   performance.measure(
-    'loadNxPlugins',
-    'loadNxPlugins:start',
-    'loadNxPlugins:end'
+    'loadSpecifiedNxPlugins',
+    'loadSpecifiedNxPlugins:start',
+    'loadSpecifiedNxPlugins:end'
   );
   return ret;
 }
 
+/**
+ * Use `getPlugins` instead.
+ * @deprecated Do not use this. Use `getPlugins` instead.
+ */
+export async function loadNxPlugins(
+  plugins: PluginConfiguration[],
+  root = workspaceRoot
+): Promise<readonly [LoadedNxPlugin[], () => void]> {
+  const defaultPlugins = await loadDefaultNxPlugins(root);
+  const specifiedPlugins = await loadSpecifiedNxPlugins(plugins, root);
+
+  const combinedCleanup = () => {
+    specifiedPlugins[1]();
+    defaultPlugins[1]();
+  };
+
+  return [specifiedPlugins[0].concat(defaultPlugins[0]), combinedCleanup];
+}
+
 async function normalizePlugins(plugins: PluginConfiguration[], root: string) {
   plugins ??= [];
 
-  return [
-    ...plugins,
-    // Most of the nx core node plugins go on the end, s.t. it overwrites any other plugins
-    ...(await getDefaultPlugins(root)),
-  ];
+  return [...plugins];
 }
 
 export async function getDefaultPlugins(root: string) {