nx 18.3.0-canary.20240409-32144bb → 18.3.0-canary.20240411-c8f179d

package/src/project-graph/plugins/isolation/plugin-pool.js

@@ -0,0 +1,189 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadRemoteNxPlugin = void 0;
+const child_process_1 = require("child_process");
+const path = require("path");
+// TODO (@AgentEnder): After scoped verbose logging is implemented, re-add verbose logs here.
+// import { logger } from '../../utils/logger';
+const internal_api_1 = require("../internal-api");
+const messaging_1 = require("./messaging");
+const cleanupFunctions = new Set();
+const pluginNames = new Map();
+function loadRemoteNxPlugin(plugin, root) {
+    // this should only really be true when running unit tests within
+    // the Nx repo. We still need to start the worker in this case,
+    // but its typescript.
+    const isWorkerTypescript = path.extname(__filename) === '.ts';
+    const workerPath = path.join(__dirname, 'plugin-worker');
+    const worker = (0, child_process_1.fork)(workerPath, [], {
+        stdio: ['ignore', 'inherit', 'inherit', 'ipc'],
+        env: {
+            ...process.env,
+            ...(isWorkerTypescript
+                ? {
+                    // Ensures that the worker uses the same tsconfig as the main process
+                    TS_NODE_PROJECT: path.join(__dirname, '../../../tsconfig.lib.json'),
+                }
+                : {}),
+        },
+        execArgv: [
+            ...process.execArgv,
+            // If the worker is typescript, we need to register ts-node
+            ...(isWorkerTypescript ? ['-r', 'ts-node/register'] : []),
+        ],
+    });
+    worker.send((0, messaging_1.createMessage)({ type: 'load', payload: { plugin, root } }));
+    // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
+    const pendingPromises = new Map();
+    const exitHandler = createWorkerExitHandler(worker, pendingPromises);
+    const cleanupFunction = () => {
+        worker.off('exit', exitHandler);
+        shutdownPluginWorker(worker, pendingPromises);
+    };
+    cleanupFunctions.add(cleanupFunction);
+    return [
+        new Promise((res, rej) => {
+            worker.on('message', createWorkerHandler(worker, pendingPromises, res, rej));
+            worker.on('exit', exitHandler);
+        }),
+        () => {
+            cleanupFunction();
+            cleanupFunctions.delete(cleanupFunction);
+        },
+    ];
+}
+exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
+async function shutdownPluginWorker(worker, pendingPromises) {
+    // Clears the plugin cache so no refs to the workers are held
+    internal_api_1.nxPluginCache.clear();
+    // logger.verbose(`[plugin-pool] starting worker shutdown`);
+    // Other things may be interacting with the worker.
+    // Wait for all pending promises to be done before killing the worker
+    await Promise.all(Array.from(pendingPromises.values()).map(({ promise }) => promise));
+    worker.kill('SIGINT');
+}
+/**
+ * Creates a message handler for the given worker.
+ * @param worker Instance of plugin-worker
+ * @param pending Set of pending promises
+ * @param onload Resolver for RemotePlugin promise
+ * @param onloadError Rejecter for RemotePlugin promise
+ * @returns Function to handle messages from the worker
+ */
+function createWorkerHandler(worker, pending, onload, onloadError) {
+    let pluginName;
+    return function (message) {
+        const parsed = JSON.parse(message);
+        // logger.verbose(
+        //   `[plugin-pool] received message: ${parsed.type} from ${
+        //     pluginName ?? worker.pid
+        //   }`
+        // );
+        (0, messaging_1.consumeMessage)(parsed, {
+            'load-result': (result) => {
+                if (result.success) {
+                    const { name, createNodesPattern } = result;
+                    pluginName = name;
+                    pluginNames.set(worker, pluginName);
+                    onload({
+                        name,
+                        createNodes: createNodesPattern
+                            ? [
+                                createNodesPattern,
+                                (configFiles, ctx) => {
+                                    const tx = pluginName + ':createNodes:' + performance.now();
+                                    return registerPendingPromise(tx, pending, () => {
+                                        worker.send((0, messaging_1.createMessage)({
+                                            type: 'createNodes',
+                                            payload: { configFiles, context: ctx, tx },
+                                        }));
+                                    });
+                                },
+                            ]
+                            : undefined,
+                        createDependencies: result.hasCreateDependencies
+                            ? (ctx) => {
+                                const tx = pluginName + ':createDependencies:' + performance.now();
+                                return registerPendingPromise(tx, pending, () => {
+                                    worker.send((0, messaging_1.createMessage)({
+                                        type: 'createDependencies',
+                                        payload: { context: ctx, tx },
+                                    }));
+                                });
+                            }
+                            : undefined,
+                        processProjectGraph: result.hasProcessProjectGraph
+                            ? (graph, ctx) => {
+                                const tx = pluginName + ':processProjectGraph:' + performance.now();
+                                return registerPendingPromise(tx, pending, () => {
+                                    worker.send((0, messaging_1.createMessage)({
+                                        type: 'processProjectGraph',
+                                        payload: { graph, ctx, tx },
+                                    }));
+                                });
+                            }
+                            : undefined,
+                    });
+                }
+                else if (result.success === false) {
+                    onloadError(result.error);
+                }
+            },
+            createDependenciesResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver(result.dependencies);
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
+            createNodesResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver(result.result);
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
+            processProjectGraphResult: ({ tx, ...result }) => {
+                const { resolver, rejector } = pending.get(tx);
+                if (result.success) {
+                    resolver(result.graph);
+                }
+                else if (result.success === false) {
+                    rejector(result.error);
+                }
+            },
+        });
+    };
+}
+function createWorkerExitHandler(worker, pendingPromises) {
+    return () => {
+        for (const [_, pendingPromise] of pendingPromises) {
+            pendingPromise.rejector(new Error(`Plugin worker ${pluginNames.get(worker) ?? worker.pid} exited unexpectedly with code ${worker.exitCode}`));
+        }
+    };
+}
+process.on('exit', () => {
+    for (const fn of cleanupFunctions) {
+        fn();
+    }
+});
+function registerPendingPromise(tx, pending, callback) {
+    let resolver, rejector;
+    const promise = new Promise((res, rej) => {
+        resolver = res;
+        rejector = rej;
+        callback();
+    }).finally(() => {
+        pending.delete(tx);
+    });
+    pending.set(tx, {
+        promise,
+        resolver,
+        rejector,
+    });
+    return promise;
+}

package/src/project-graph/plugins/isolation/plugin-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/src/project-graph/plugins/isolation/plugin-worker.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const messaging_1 = require("./messaging");
+const loader_1 = require("../loader");
+global.NX_GRAPH_CREATION = true;
+let plugin;
+process.on('message', async (message) => {
+    (0, messaging_1.consumeMessage)(message, {
+        load: async ({ plugin: pluginConfiguration, root }) => {
+            process.chdir(root);
+            try {
+                const [promise] = (0, loader_1.loadNxPlugin)(pluginConfiguration, root);
+                plugin = await promise;
+                return {
+                    type: 'load-result',
+                    payload: {
+                        name: plugin.name,
+                        createNodesPattern: plugin.createNodes?.[0],
+                        hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
+                        hasProcessProjectGraph: 'processProjectGraph' in plugin && !!plugin.processProjectGraph,
+                        success: true,
+                    },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'load-result',
+                    payload: {
+                        success: false,
+                        error: `Could not load plugin ${plugin} \n ${e instanceof Error ? e.stack : ''}`,
+                    },
+                };
+            }
+        },
+        createNodes: async ({ configFiles, context, tx }) => {
+            try {
+                const result = await plugin.createNodes[1](configFiles, context);
+                return {
+                    type: 'createNodesResult',
+                    payload: { result, success: true, tx },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'createNodesResult',
+                    payload: { success: false, error: e.stack, tx },
+                };
+            }
+        },
+        createDependencies: async ({ context, tx }) => {
+            try {
+                const result = await plugin.createDependencies(context);
+                return {
+                    type: 'createDependenciesResult',
+                    payload: { dependencies: result, success: true, tx },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'createDependenciesResult',
+                    payload: { success: false, error: e.stack, tx },
+                };
+            }
+        },
+        processProjectGraph: async ({ graph, ctx, tx }) => {
+            try {
+                const result = await plugin.processProjectGraph(graph, ctx);
+                return {
+                    type: 'processProjectGraphResult',
+                    payload: { graph: result, success: true, tx },
+                };
+            }
+            catch (e) {
+                return {
+                    type: 'processProjectGraphResult',
+                    payload: { success: false, error: e.stack, tx },
+                };
+            }
+        },
+    });
+});

package/src/project-graph/plugins/loader.d.ts

@@ -0,0 +1,24 @@
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { PackageJson } from '../../utils/package-json';
+import { PluginConfiguration } from '../../config/nx-json';
+import { LoadedNxPlugin } from './internal-api';
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function resolveLocalNxPlugin(importPath: string, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+export declare let unregisterPluginTSTranspiler: (() => void) | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+};
+export declare function loadNxPlugin(plugin: PluginConfiguration, root: string): readonly [Promise<LoadedNxPlugin>, () => void];
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], root: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/loader.js

@@ -0,0 +1,206 @@
+"use strict";
+// This file contains methods and utilities that should **only** be used by the plugin worker.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadNxPluginAsync = exports.loadNxPlugin = exports.getPluginPathAndName = exports.registerPluginTSTranspiler = exports.unregisterPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = void 0;
+const posix_1 = require("node:path/posix");
+const installation_directory_1 = require("../../utils/installation-directory");
+const package_json_1 = require("../../utils/package-json");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_root_1 = require("../../utils/workspace-root");
+const node_fs_1 = require("node:fs");
+const typescript_1 = require("../../utils/typescript");
+const register_1 = require("../../plugins/js/utils/register");
+const find_project_for_path_1 = require("../utils/find-project-for-path");
+const path_1 = require("../../utils/path");
+const logger_1 = require("../../utils/logger");
+const node_path_1 = require("node:path");
+const path = require("node:path/posix");
+const retrieve_workspace_files_1 = require("../utils/retrieve-workspace-files");
+const utils_1 = require("./utils");
+const internal_api_1 = require("./internal-api");
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+    try {
+        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
+        return {
+            json: result.packageJson,
+            path: result.path,
+        };
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const localPluginPath = resolveLocalNxPlugin(pluginName, projects);
+            if (localPluginPath) {
+                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                return {
+                    path: localPluginPackageJson,
+                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
+                };
+            }
+        }
+        throw e;
+    }
+}
+exports.readPluginPackageJson = readPluginPackageJson;
+function resolveLocalNxPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    return lookupLocalPlugin(importPath, projects, root);
+}
+exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
+exports.unregisterPluginTSTranspiler = null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    // Get the first tsconfig that matches the allowed set
+    const tsConfigName = [
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+        (0, posix_1.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+    ].find((x) => (0, node_fs_1.existsSync)(x));
+    if (!tsConfigName) {
+        return;
+    }
+    const tsConfig = tsConfigName
+        ? (0, typescript_1.readTsConfig)(tsConfigName)
+        : {};
+    const cleanupFns = [
+        (0, register_1.registerTsConfigPaths)(tsConfigName),
+        (0, register_1.registerTranspiler)({
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            ...tsConfig.options,
+        }),
+    ];
+    exports.unregisterPluginTSTranspiler = () => {
+        cleanupFns.forEach((fn) => fn?.());
+    };
+}
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+function lookupLocalPlugin(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const plugin = findNxProjectForImportPath(importPath, projects, root);
+    if (!plugin) {
+        return null;
+    }
+    const projectConfig = projects[plugin];
+    return { path: path.join(root, projectConfig.root), projectConfig };
+}
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
+    if (possiblePaths?.length) {
+        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+        for (const tsConfigPath of possiblePaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return nxProject;
+            }
+        }
+        logger_1.logger.verbose('Unable to find local plugin', possiblePaths, projectRootMappings);
+        throw new Error('Unable to resolve local plugin with import path ' + importPath);
+    }
+}
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, node_fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
+        }
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
+    }
+    return tsconfigPaths ?? {};
+}
+function readPluginMainFromProjectConfiguration(plugin) {
+    const { main } = Object.values(plugin.targets).find((x) => [
+        '@nx/js:tsc',
+        '@nrwl/js:tsc',
+        '@nx/js:swc',
+        '@nrwl/js:swc',
+        '@nx/node:package',
+        '@nrwl/node:package',
+    ].includes(x.executor))?.options ||
+        plugin.targets?.build?.options ||
+        {};
+    return main;
+}
+function getPluginPathAndName(moduleName, paths, projects, root) {
+    let pluginPath;
+    let registerTSTranspiler = false;
+    try {
+        pluginPath = require.resolve(moduleName, {
+            paths,
+        });
+        const extension = path.extname(pluginPath);
+        registerTSTranspiler = extension === '.ts';
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const plugin = resolveLocalNxPlugin(moduleName, projects, root);
+            if (plugin) {
+                registerTSTranspiler = true;
+                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+                pluginPath = main ? path.join(root, main) : plugin.path;
+            }
+            else {
+                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+                throw e;
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    // Register the ts-transpiler if we are pointing to a
+    // plain ts file that's not part of a plugin project
+    if (registerTSTranspiler) {
+        registerPluginTSTranspiler();
+    }
+    const { name } = !['.ts', '.js'].some((x) => (0, node_path_1.extname)(moduleName) === x) && // Not trying to point to a ts or js file
+        (0, node_fs_1.existsSync)(packageJsonPath) // plugin has a package.json
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
+        : { name: moduleName };
+    return { pluginPath, name };
+}
+exports.getPluginPathAndName = getPluginPathAndName;
+let projectsWithoutInference;
+function loadNxPlugin(plugin, root) {
+    return [
+        loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), root),
+        () => { },
+    ];
+}
+exports.loadNxPlugin = loadNxPlugin;
+async function loadNxPluginAsync(pluginConfiguration, paths, root) {
+    try {
+        require.resolve(typeof pluginConfiguration === 'string'
+            ? pluginConfiguration
+            : pluginConfiguration.plugin);
+    }
+    catch {
+        // If a plugin cannot be resolved, we will need projects to resolve it
+        projectsWithoutInference ??=
+            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+    }
+    const moduleName = typeof pluginConfiguration === 'string'
+        ? pluginConfiguration
+        : pluginConfiguration.plugin;
+    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projectsWithoutInference, root);
+    const plugin = (0, utils_1.normalizeNxPlugin)(await importPluginModule(pluginPath));
+    plugin.name ??= name;
+    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+    return new internal_api_1.LoadedNxPlugin(plugin, pluginConfiguration);
+}
+exports.loadNxPluginAsync = loadNxPluginAsync;
+async function importPluginModule(pluginPath) {
+    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
+    if (m.default &&
+        ('createNodes' in m.default || 'createDependencies' in m.default)) {
+        return m.default;
+    }
+    return m;
+}

package/src/{utils/nx-plugin.d.ts → project-graph/plugins/public-api.d.ts}

@@ -1,9 +1,8 @@
-import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
-import { PackageJson } from './package-json';
-import { ProjectConfiguration } from '../config/workspace-json-project-json';
-import { NxJsonConfiguration, PluginConfiguration } from '../config/nx-json';
-import { NxPluginV1 } from './nx-plugin.deprecated';
-import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
+import { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../../config/project-graph';
+import { ProjectConfiguration } from '../../config/workspace-json-project-json';
+import { NxJsonConfiguration } from '../../config/nx-json';
+import { RawProjectGraphDependency } from '../project-graph-builder';
 /**
  * Context for {@link CreateNodesFunction}
  */
@@ -20,6 +19,7 @@ export interface CreateNodesContext {
  * Used for creating nodes for the {@link ProjectGraph}
  */
 export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;
 export interface CreateNodesResult {
     /**
      * A map of project root -> project configuration
@@ -34,7 +34,7 @@ export interface CreateNodesResult {
  * A pair of file patterns and {@link CreateNodesFunction}
  */
 export type CreateNodes<T = unknown> = readonly [
-    configFilePattern: string,
+    projectFilePattern: string,
     createNodesFunction: CreateNodesFunction<T>
 ];
 /**
@@ -77,49 +77,13 @@ export type NxPluginV2<TOptions = unknown> = {
      * Provides a file pattern and function that retrieves configuration info from
      * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
      */
-    createNodes?: CreateNodes;
+    createNodes?: CreateNodes<TOptions>;
     /**
      * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
      */
     createDependencies?: CreateDependencies<TOptions>;
 };
-export * from './nx-plugin.deprecated';
 /**
  * A plugin for Nx
  */
 export type NxPlugin = NxPluginV1 | NxPluginV2;
-export type LoadedNxPlugin = {
-    plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
-    options?: unknown;
-    include?: string[];
-    exclude?: string[];
-};
-export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
-export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
-    pluginPath: string;
-    name: any;
-};
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
-export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string, projects?: Record<string, ProjectConfiguration>): Promise<LoadedNxPlugin[]>;
-export declare function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2;
-export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
-export declare function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1;
-export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
-    path: string;
-    json: PackageJson;
-};
-export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
-    path: string;
-    projectConfig: ProjectConfiguration;
-} | null;
-/**
- * Register swc-node or ts-node if they are not currently registered
- * with some default settings which work well for Nx plugins.
- */
-export declare function registerPluginTSTranspiler(): void;
-/**
- * Unregister the ts-node transpiler if it is registered
- */
-export declare function unregisterPluginTSTranspiler(): void;
-export declare function getDefaultPlugins(root: string): Promise<LoadedNxPlugin[]>;
-type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/project-graph/plugins/public-api.js

@@ -0,0 +1,4 @@
+"use strict";
+// This file represents the public API for plugins which live in nx.json's plugins array.
+// For methods to interact with plugins from within Nx, see `./internal-api.ts`.
+Object.defineProperty(exports, "__esModule", { value: true });

package/src/project-graph/plugins/utils.d.ts

@@ -0,0 +1,7 @@
+import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
+import type { CreateNodesResultWithContext, LoadedNxPlugin, NormalizedPlugin } from './internal-api';
+import type { CreateNodesContext, NxPlugin, NxPluginV2 } from './public-api';
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin | LoadedNxPlugin): plugin is NxPluginV1;
+export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
+export declare function runCreateNodesInParallel(configFiles: string[], plugin: NormalizedPlugin, options: unknown, context: CreateNodesContext): Promise<CreateNodesResultWithContext[]>;