nx 18.1.0-canary.20240309-235ca8c → 18.1.0-canary.20240312-9520aa2

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>;

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

@@ -1,195 +0,0 @@
-"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.loadPlugin = exports.loadPlugins = exports.getPluginPathAndName = exports.registerPluginTSTranspiler = 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");
-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;
-/**
- * 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));
-    const tsConfig = tsConfigName
-        ? (0, typescript_1.readTsConfig)(tsConfigName)
-        : {};
-    (0, register_1.registerTsConfigPaths)(tsConfigName);
-    (0, register_1.registerTranspiler)({
-        experimentalDecorators: true,
-        emitDecoratorMetadata: true,
-        ...tsConfig.options,
-    });
-}
-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;
-async function loadPlugins(plugins, root) {
-    return await Promise.all(plugins.map((p) => loadPlugin(p, root)));
-}
-exports.loadPlugins = loadPlugins;
-async function loadPlugin(plugin, root) {
-    try {
-        require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
-    }
-    catch {
-        // If a plugin cannot be resolved, we will need projects to resolve it
-        projectsWithoutInference ??=
-            await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
-    }
-    return await loadNxPluginAsync(plugin, (0, installation_directory_1.getNxRequirePaths)(root), projectsWithoutInference, root);
-}
-exports.loadPlugin = loadPlugin;
-async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
-    const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
-        ? pluginConfiguration
-        : { plugin: pluginConfiguration, options: undefined };
-    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
-    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, 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 { plugin, options };
-}
-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;
-}