nx 18.1.0-canary.20240309-235ca8c → 18.1.0-canary.20240313-81df848

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

@@ -1,64 +0,0 @@
-"use strict";
-// This file contains the bits and bobs of the internal API for loading and interacting with Nx plugins.
-// For the public API, used by plugin authors, see `./public-api.ts`.
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.getDefaultPlugins = exports.loadNxPluginInIsolation = exports.loadNxPluginsInIsolation = exports.nxPluginCache = exports.loadPlugin = exports.loadPlugins = void 0;
-const path_1 = require("path");
-const workspace_root_1 = require("../../utils/workspace-root");
-const angular_json_1 = require("../../adapter/angular-json");
-const plugin_pool_1 = require("./plugin-pool");
-var worker_api_1 = require("./worker-api");
-Object.defineProperty(exports, "loadPlugins", { enumerable: true, get: function () { return worker_api_1.loadPlugins; } });
-Object.defineProperty(exports, "loadPlugin", { enumerable: true, get: function () { return worker_api_1.loadPlugin; } });
-// Short lived cache (cleared between cmd runs)
-// holding resolved nx plugin objects.
-// Allows loaded plugins to not be reloaded when
-// referenced multiple times.
-exports.nxPluginCache = new Map();
-/**
- * This loads plugins in isolation in their own worker so that they do not disturb other workers or the main process.
- */
-async function loadNxPluginsInIsolation(plugins, root = workspace_root_1.workspaceRoot) {
-    const result = [];
-    plugins ??= [];
-    plugins.unshift((0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/package-json-next-to-project-json'));
-    // We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
-    plugins.push(...(await getDefaultPlugins(root)));
-    const cleanupFunctions = [];
-    for (const plugin of plugins) {
-        const [loadedPluginPromise, cleanup] = loadNxPluginInIsolation(plugin, root);
-        result.push(loadedPluginPromise);
-        cleanupFunctions.push(cleanup);
-    }
-    return [
-        await Promise.all(result),
-        () => {
-            for (const fn of cleanupFunctions) {
-                fn();
-            }
-        },
-    ];
-}
-exports.loadNxPluginsInIsolation = loadNxPluginsInIsolation;
-function loadNxPluginInIsolation(plugin, root = workspace_root_1.workspaceRoot) {
-    const cacheKey = JSON.stringify(plugin);
-    if (exports.nxPluginCache.has(cacheKey)) {
-        return exports.nxPluginCache.get(cacheKey);
-    }
-    const [loadingPlugin, cleanup] = (0, plugin_pool_1.loadRemoteNxPlugin)(plugin, root);
-    exports.nxPluginCache.set(cacheKey, [loadingPlugin, cleanup]);
-    return [loadingPlugin, cleanup];
-}
-exports.loadNxPluginInIsolation = loadNxPluginInIsolation;
-async function getDefaultPlugins(root) {
-    return [
-        (0, path_1.join)(__dirname, '../../plugins/js'),
-        (0, path_1.join)(__dirname, '../../plugins/target-defaults/target-defaults-plugin'),
-        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
-            ? [(0, path_1.join)(__dirname, '../../adapter/angular-json')]
-            : []),
-        (0, path_1.join)(__dirname, '../../plugins/package-json-workspaces'),
-        (0, path_1.join)(__dirname, '../../plugins/project-json/build-nodes/project-json'),
-    ];
-}
-exports.getDefaultPlugins = getDefaultPlugins;

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

@@ -1,94 +0,0 @@
-import { ProjectGraph, ProjectGraphProcessorContext } from '../../config/project-graph';
-import { PluginConfiguration } from '../../config/nx-json';
-import { CreateDependenciesContext, CreateNodesContext } from './public-api';
-import { RemotePlugin } from './internal-api';
-export interface PluginWorkerLoadMessage {
-    type: 'load';
-    payload: {
-        plugin: PluginConfiguration;
-        root: string;
-    };
-}
-export interface PluginWorkerLoadResult {
-    type: 'load-result';
-    payload: {
-        name: string;
-        createNodesPattern: string;
-        hasCreateDependencies: boolean;
-        hasProcessProjectGraph: boolean;
-        success: true;
-    } | {
-        success: false;
-        error: string;
-    };
-}
-export interface PluginWorkerCreateNodesMessage {
-    type: 'createNodes';
-    payload: {
-        configFiles: string[];
-        context: CreateNodesContext;
-        tx: string;
-    };
-}
-export interface PluginWorkerCreateNodesResult {
-    type: 'createNodesResult';
-    payload: {
-        success: true;
-        result: Awaited<ReturnType<RemotePlugin['createNodes'][1]>>;
-        tx: string;
-    } | {
-        success: false;
-        error: string;
-        tx: string;
-    };
-}
-export interface PluginCreateDependenciesMessage {
-    type: 'createDependencies';
-    payload: {
-        context: CreateDependenciesContext;
-        tx: string;
-    };
-}
-export interface PluginCreateDependenciesResult {
-    type: 'createDependenciesResult';
-    payload: {
-        dependencies: ReturnType<RemotePlugin['createDependencies']>;
-        success: true;
-        tx: string;
-    } | {
-        success: false;
-        error: string;
-        tx: string;
-    };
-}
-export interface PluginWorkerProcessProjectGraphMessage {
-    type: 'processProjectGraph';
-    payload: {
-        graph: ProjectGraph;
-        ctx: ProjectGraphProcessorContext;
-        tx: string;
-    };
-}
-export interface PluginWorkerProcessProjectGraphResult {
-    type: 'processProjectGraphResult';
-    payload: {
-        graph: ProjectGraph;
-        success: true;
-        tx: string;
-    } | {
-        success: false;
-        error: string;
-        tx: string;
-    };
-}
-export type PluginWorkerMessage = PluginWorkerLoadMessage | PluginWorkerCreateNodesMessage | PluginCreateDependenciesMessage | PluginWorkerProcessProjectGraphMessage;
-export type PluginWorkerResult = PluginWorkerLoadResult | PluginWorkerCreateNodesResult | PluginCreateDependenciesResult | PluginWorkerProcessProjectGraphResult;
-type MaybePromise<T> = T | Promise<T>;
-type MessageHandlerReturn<T extends PluginWorkerMessage | PluginWorkerResult> = T extends PluginWorkerResult ? MaybePromise<PluginWorkerMessage | void> : MaybePromise<PluginWorkerResult | void>;
-export declare function consumeMessage<T extends PluginWorkerMessage | PluginWorkerResult>(raw: string | T, handlers: {
-    [K in T['type']]: (payload: Extract<T, {
-        type: K;
-    }>['payload']) => MessageHandlerReturn<T>;
-}): Promise<void>;
-export declare function createMessage(message: PluginWorkerMessage | PluginWorkerResult): string;
-export {};

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

@@ -1,23 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createMessage = exports.consumeMessage = void 0;
-// Takes a message and a map of handlers and calls the appropriate handler
-// type safe and requires all handlers to be handled
-async function consumeMessage(raw, handlers) {
-    const message = typeof raw === 'string' ? JSON.parse(raw) : raw;
-    const handler = handlers[message.type];
-    if (handler) {
-        const response = await handler(message.payload);
-        if (response) {
-            process.send(createMessage(response));
-        }
-    }
-    else {
-        throw new Error(`Unhandled message type: ${message.type}`);
-    }
-}
-exports.consumeMessage = consumeMessage;
-function createMessage(message) {
-    return JSON.stringify(message);
-}
-exports.createMessage = createMessage;

package/src/project-graph/plugins/plugin-pool.d.ts

@@ -1,3 +0,0 @@
-import { PluginConfiguration } from '../../config/nx-json';
-import { RemotePlugin } from './internal-api';
-export declare function loadRemoteNxPlugin(plugin: PluginConfiguration, root: string): readonly [Promise<RemotePlugin>, () => void];

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

@@ -1,189 +0,0 @@
-"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
-                            ? (opts, 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/plugin-worker.d.ts

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

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

@@ -1,101 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const messaging_1 = require("./messaging");
-const utils_1 = require("./utils");
-const worker_api_1 = require("./worker-api");
-global.NX_GRAPH_CREATION = true;
-let plugin;
-let pluginOptions;
-process.on('message', async (message) => {
-    (0, messaging_1.consumeMessage)(message, {
-        load: async ({ plugin: pluginConfiguration, root }) => {
-            process.chdir(root);
-            try {
-                ({ plugin, options: pluginOptions } = await (0, worker_api_1.loadPlugin)(pluginConfiguration, root));
-                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 runCreateNodesInParallel(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(pluginOptions, 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 },
-                };
-            }
-        },
-    });
-});
-function runCreateNodesInParallel(configFiles, context) {
-    const promises = configFiles.map((file) => {
-        performance.mark(`${plugin.name}:createNodes:${file} - start`);
-        // Result is either static or a promise, using Promise.resolve lets us
-        // handle both cases with same logic
-        const value = Promise.resolve(plugin.createNodes[1](file, pluginOptions, context));
-        return value
-            .catch((e) => {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
-            throw new utils_1.CreateNodesError(`Unable to create nodes for ${file} using plugin ${plugin.name}.`, e);
-        })
-            .then((r) => {
-            performance.mark(`${plugin.name}:createNodes:${file} - end`);
-            performance.measure(`${plugin.name}:createNodes:${file}`, `${plugin.name}:createNodes:${file} - start`, `${plugin.name}:createNodes:${file} - end`);
-            return { ...r, pluginName: plugin.name, file };
-        });
-    });
-    return Promise.all(promises);
-}

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

@@ -1,4 +0,0 @@
-"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

@@ -1,9 +0,0 @@
-import type { NxPluginV1 } from '../../utils/nx-plugin.deprecated';
-import type { NormalizedPlugin, RemotePlugin } from './internal-api';
-import type { NxPlugin, NxPluginV2 } from './public-api';
-export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
-export declare function isNxPluginV1(plugin: NxPlugin | RemotePlugin): plugin is NxPluginV1;
-export declare function normalizeNxPlugin(plugin: NxPlugin): NormalizedPlugin;
-export declare class CreateNodesError extends Error {
-    constructor(msg: any, cause: Error | unknown);
-}

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

@@ -1,55 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CreateNodesError = exports.normalizeNxPlugin = exports.isNxPluginV1 = exports.isNxPluginV2 = void 0;
-const node_path_1 = require("node:path");
-const workspaces_1 = require("../../config/workspaces");
-const globs_1 = require("../../utils/globs");
-function isNxPluginV2(plugin) {
-    return 'createNodes' in plugin || 'createDependencies' in plugin;
-}
-exports.isNxPluginV2 = isNxPluginV2;
-function isNxPluginV1(plugin) {
-    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
-}
-exports.isNxPluginV1 = isNxPluginV1;
-function normalizeNxPlugin(plugin) {
-    if (isNxPluginV2(plugin)) {
-        return plugin;
-    }
-    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
-        return {
-            ...plugin,
-            createNodes: [
-                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
-                (configFilePath) => {
-                    const root = (0, node_path_1.dirname)(configFilePath);
-                    return {
-                        projects: {
-                            [root]: {
-                                name: (0, workspaces_1.toProjectName)(configFilePath),
-                                targets: plugin.registerProjectTargets?.(configFilePath),
-                            },
-                        },
-                    };
-                },
-            ],
-        };
-    }
-    return plugin;
-}
-exports.normalizeNxPlugin = normalizeNxPlugin;
-class CreateNodesError extends Error {
-    constructor(msg, cause) {
-        const message = `${msg} ${!cause
-            ? ''
-            : cause instanceof Error
-                ? `\n\n\t Inner Error: ${cause.stack}`
-                : cause}`;
-        // These errors are thrown during a JS callback which is invoked via rust.
-        // The errors messaging gets lost in the rust -> js -> rust transition, but
-        // logging the error here will ensure that it is visible in the console.
-        console.error(message);
-        super(message, { cause });
-    }
-}
-exports.CreateNodesError = CreateNodesError;

package/src/project-graph/plugins/worker-api.d.ts

@@ -1,28 +0,0 @@
-import { ProjectConfiguration } from '../../config/workspace-json-project-json';
-import { PackageJson } from '../../utils/package-json';
-import { NxPlugin } from './public-api';
-import { PluginConfiguration } from '../../config/nx-json';
-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;
-/**
- * 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 loadPlugins(plugins: PluginConfiguration[], root: string): Promise<LoadedNxPlugin[]>;
-export declare function loadPlugin(plugin: PluginConfiguration, root: string): Promise<LoadedNxPlugin>;
-export type LoadedNxPlugin = {
-    plugin: NxPlugin;
-    options?: unknown;
-};
-export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;