nx 20.8.4 → 22.7.7

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

@@ -1,50 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isPluginWorkerMessage = isPluginWorkerMessage;
-exports.isPluginWorkerResult = isPluginWorkerResult;
-exports.consumeMessage = consumeMessage;
-exports.sendMessageOverSocket = sendMessageOverSocket;
-function isPluginWorkerMessage(message) {
-    return (typeof message === 'object' &&
-        'type' in message &&
-        typeof message.type === 'string' &&
-        [
-            'load',
-            'createNodes',
-            'createDependencies',
-            'createMetadata',
-            'processProjectGraph',
-            'shutdown',
-            'preTasksExecution',
-            'postTasksExecution',
-        ].includes(message.type));
-}
-function isPluginWorkerResult(message) {
-    return (typeof message === 'object' &&
-        'type' in message &&
-        typeof message.type === 'string' &&
-        [
-            'load-result',
-            'createNodesResult',
-            'createDependenciesResult',
-            'processProjectGraphResult',
-            'createMetadataResult',
-            'preTasksExecutionResult',
-            'postTasksExecutionResult',
-        ].includes(message.type));
-}
-// 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(socket, raw, handlers) {
-    const message = raw;
-    const handler = handlers[message.type];
-    if (handler) {
-        const response = await handler(message.payload);
-        if (response) {
-            sendMessageOverSocket(socket, response);
-        }
-    }
-}
-function sendMessageOverSocket(socket, message) {
-    socket.write(JSON.stringify(message) + String.fromCodePoint(4));
-}

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

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

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

@@ -1,310 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadRemoteNxPlugin = loadRemoteNxPlugin;
-const child_process_1 = require("child_process");
-const path = require("path");
-const net_1 = require("net");
-const socket_utils_1 = require("../../../daemon/socket-utils");
-const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
-const messaging_1 = require("./messaging");
-const installation_directory_1 = require("../../../utils/installation-directory");
-const resolve_plugin_1 = require("../resolve-plugin");
-const cleanupFunctions = new Set();
-const pluginNames = new Map();
-const PLUGIN_TIMEOUT_HINT_TEXT = 'As a last resort, you can set NX_PLUGIN_NO_TIMEOUTS=true to bypass this timeout.';
-const MINUTES = 10;
-const MAX_MESSAGE_WAIT = process.env.NX_PLUGIN_NO_TIMEOUTS === 'true'
-    ? // Registering a timeout prevents the process from exiting
-        // if the call to a plugin happens to be the only thing
-        // keeping the process alive. As such, even if timeouts are disabled
-        // we need to register one. 2147483647 is the max timeout
-        // that Node.js allows, and is equivalent to 24.8 days....
-        // This does mean that the NX_PLUGIN_NO_TIMEOUTS env var
-        // would still timeout after 24.8 days, but that seems
-        // like a reasonable compromise.
-        2147483647
-    : 1000 * 60 * MINUTES; // 10 minutes
-const nxPluginWorkerCache = (global['nxPluginWorkerCache'] ??= new Map());
-async function loadRemoteNxPlugin(plugin, root) {
-    const cacheKey = JSON.stringify({ plugin, root });
-    if (nxPluginWorkerCache.has(cacheKey)) {
-        return [nxPluginWorkerCache.get(cacheKey), () => { }];
-    }
-    const moduleName = typeof plugin === 'string' ? plugin : plugin.plugin;
-    const { name, pluginPath, shouldRegisterTSTranspiler } = await (0, resolve_plugin_1.resolveNxPlugin)(moduleName, root, (0, installation_directory_1.getNxRequirePaths)(root));
-    const { worker, socket } = await startPluginWorker();
-    const pendingPromises = new Map();
-    const exitHandler = createWorkerExitHandler(worker, pendingPromises);
-    const cleanupFunction = () => {
-        worker.off('exit', exitHandler);
-        socket.destroy();
-        nxPluginWorkerCache.delete(cacheKey);
-    };
-    cleanupFunctions.add(cleanupFunction);
-    const pluginPromise = new Promise((res, rej) => {
-        (0, messaging_1.sendMessageOverSocket)(socket, {
-            type: 'load',
-            payload: { plugin, root, name, pluginPath, shouldRegisterTSTranspiler },
-        });
-        // logger.verbose(`[plugin-worker] started worker: ${worker.pid}`);
-        const loadTimeout = setTimeout(() => {
-            rej(new Error(`Loading "${typeof plugin === 'string' ? plugin : plugin.plugin}" timed out after ${MINUTES} minutes. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
-        }, MAX_MESSAGE_WAIT);
-        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(createWorkerHandler(worker, pendingPromises, (val) => {
-            if (loadTimeout)
-                clearTimeout(loadTimeout);
-            res(val);
-        }, rej, socket)));
-        worker.on('exit', exitHandler);
-    });
-    nxPluginWorkerCache.set(cacheKey, pluginPromise);
-    return [pluginPromise, cleanupFunction];
-}
-/**
- * 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, socket) {
-    let pluginName;
-    let txId = 0;
-    return function (raw) {
-        const message = JSON.parse(raw);
-        if (!(0, messaging_1.isPluginWorkerResult)(message)) {
-            return;
-        }
-        return (0, messaging_1.consumeMessage)(socket, message, {
-            'load-result': (result) => {
-                if (result.success) {
-                    const { name, createNodesPattern, include, exclude } = result;
-                    pluginName = name;
-                    pluginNames.set(worker, pluginName);
-                    onload({
-                        name,
-                        include,
-                        exclude,
-                        createNodes: createNodesPattern
-                            ? [
-                                createNodesPattern,
-                                (configFiles, ctx) => {
-                                    const tx = pluginName + worker.pid + ':createNodes:' + txId++;
-                                    return registerPendingPromise(tx, pending, () => {
-                                        (0, messaging_1.sendMessageOverSocket)(socket, {
-                                            type: 'createNodes',
-                                            payload: { configFiles, context: ctx, tx },
-                                        });
-                                    }, {
-                                        plugin: pluginName,
-                                        operation: 'createNodes',
-                                    });
-                                },
-                            ]
-                            : undefined,
-                        createDependencies: result.hasCreateDependencies
-                            ? (ctx) => {
-                                const tx = pluginName + worker.pid + ':createDependencies:' + txId++;
-                                return registerPendingPromise(tx, pending, () => {
-                                    (0, messaging_1.sendMessageOverSocket)(socket, {
-                                        type: 'createDependencies',
-                                        payload: { context: ctx, tx },
-                                    });
-                                }, {
-                                    plugin: pluginName,
-                                    operation: 'createDependencies',
-                                });
-                            }
-                            : undefined,
-                        createMetadata: result.hasCreateMetadata
-                            ? (graph, ctx) => {
-                                const tx = pluginName + worker.pid + ':createMetadata:' + txId++;
-                                return registerPendingPromise(tx, pending, () => {
-                                    (0, messaging_1.sendMessageOverSocket)(socket, {
-                                        type: 'createMetadata',
-                                        payload: { graph, context: ctx, tx },
-                                    });
-                                }, {
-                                    plugin: pluginName,
-                                    operation: 'createMetadata',
-                                });
-                            }
-                            : undefined,
-                        preTasksExecution: result.hasPreTasksExecution
-                            ? (context) => {
-                                const tx = pluginName + worker.pid + ':preTasksExecution:' + txId++;
-                                return registerPendingPromise(tx, pending, () => {
-                                    (0, messaging_1.sendMessageOverSocket)(socket, {
-                                        type: 'preTasksExecution',
-                                        payload: { tx, context },
-                                    });
-                                }, {
-                                    plugin: pluginName,
-                                    operation: 'preTasksExecution',
-                                });
-                            }
-                            : undefined,
-                        postTasksExecution: result.hasPostTasksExecution
-                            ? (context) => {
-                                const tx = pluginName + worker.pid + ':postTasksExecution:' + txId++;
-                                return registerPendingPromise(tx, pending, () => {
-                                    (0, messaging_1.sendMessageOverSocket)(socket, {
-                                        type: 'postTasksExecution',
-                                        payload: { tx, context },
-                                    });
-                                }, {
-                                    plugin: pluginName,
-                                    operation: 'postTasksExecution',
-                                });
-                            }
-                            : 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);
-                }
-            },
-            createMetadataResult: ({ tx, ...result }) => {
-                const { resolver, rejector } = pending.get(tx);
-                if (result.success) {
-                    resolver(result.metadata);
-                }
-                else if (result.success === false) {
-                    rejector(result.error);
-                }
-            },
-            preTasksExecutionResult: ({ tx, ...result }) => {
-                const { resolver, rejector } = pending.get(tx);
-                if (result.success) {
-                    resolver(result.mutations);
-                }
-                else if (result.success === false) {
-                    rejector(result.error);
-                }
-            },
-            postTasksExecutionResult: ({ tx, ...result }) => {
-                const { resolver, rejector } = pending.get(tx);
-                if (result.success) {
-                    resolver();
-                }
-                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}`));
-        }
-    };
-}
-function registerPendingPromise(tx, pending, callback, context) {
-    let resolver, rejector, timeout;
-    const promise = new Promise((res, rej) => {
-        rejector = rej;
-        resolver = res;
-        timeout = setTimeout(() => {
-            rej(new Error(`${context.plugin} timed out after ${MINUTES} minutes during ${context.operation}. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
-        }, MAX_MESSAGE_WAIT);
-        callback();
-    }).finally(() => {
-        pending.delete(tx);
-        if (timeout)
-            clearTimeout(timeout);
-    });
-    pending.set(tx, {
-        promise,
-        resolver,
-        rejector,
-    });
-    return promise;
-}
-global.nxPluginWorkerCount ??= 0;
-async function startPluginWorker() {
-    // 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 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'),
-            }
-            : {}),
-    };
-    const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)([process.pid, global.nxPluginWorkerCount++].join('-'));
-    const worker = (0, child_process_1.spawn)(process.execPath, [
-        ...(isWorkerTypescript ? ['--require', 'ts-node/register'] : []),
-        workerPath,
-        ipcPath,
-    ], {
-        stdio: 'inherit',
-        env,
-        detached: true,
-        shell: false,
-        windowsHide: true,
-    });
-    worker.unref();
-    let attempts = 0;
-    return new Promise((resolve, reject) => {
-        const id = setInterval(async () => {
-            const socket = await isServerAvailable(ipcPath);
-            if (socket) {
-                socket.unref();
-                clearInterval(id);
-                resolve({
-                    worker,
-                    socket,
-                });
-            }
-            else if (attempts > 10000) {
-                // daemon fails to start, the process probably exited
-                // we print the logs and exit the client
-                reject('Failed to start plugin worker.');
-            }
-            else {
-                attempts++;
-            }
-        }, 10);
-    });
-}
-function isServerAvailable(ipcPath) {
-    return new Promise((resolve) => {
-        try {
-            const socket = (0, net_1.connect)(ipcPath, () => {
-                resolve(socket);
-            });
-            socket.once('error', () => {
-                resolve(false);
-            });
-        }
-        catch (err) {
-            resolve(false);
-        }
-    });
-}

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

@@ -1,208 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-const node_perf_hooks_1 = require("node:perf_hooks");
-node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- start`);
-const messaging_1 = require("./messaging");
-const serializable_error_1 = require("../../../utils/serializable-error");
-const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
-const net_1 = require("net");
-const fs_1 = require("fs");
-if (process.env.NX_PERF_LOGGING === 'true') {
-    require('../../../utils/perf-logging');
-}
-node_perf_hooks_1.performance.mark(`plugin worker ${process.pid} code loading -- end`);
-node_perf_hooks_1.performance.measure(`plugin worker ${process.pid} code loading`, `plugin worker ${process.pid} code loading -- start`, `plugin worker ${process.pid} code loading -- end`);
-global.NX_GRAPH_CREATION = true;
-global.NX_PLUGIN_WORKER = true;
-let connected = false;
-let plugin;
-const socketPath = process.argv[2];
-const server = (0, net_1.createServer)((socket) => {
-    connected = true;
-    // This handles cases where the host process was killed
-    // after the worker connected but before the worker was
-    // instructed to load the plugin.
-    const loadTimeout = setTimeout(() => {
-        console.error(`Plugin Worker exited because no plugin was loaded within 10 seconds of starting up.`);
-        process.exit(1);
-    }, 10000).unref();
-    socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)((raw) => {
-        const message = JSON.parse(raw.toString());
-        if (!(0, messaging_1.isPluginWorkerMessage)(message)) {
-            return;
-        }
-        return (0, messaging_1.consumeMessage)(socket, message, {
-            load: async ({ plugin: pluginConfiguration, root, name, pluginPath, shouldRegisterTSTranspiler, }) => {
-                if (loadTimeout)
-                    clearTimeout(loadTimeout);
-                process.chdir(root);
-                try {
-                    const { loadResolvedNxPluginAsync } = await Promise.resolve().then(() => require('../load-resolved-plugin'));
-                    // Register the ts-transpiler if we are pointing to a
-                    // plain ts file that's not part of a plugin project
-                    if (shouldRegisterTSTranspiler) {
-                        require('../transpiler').registerPluginTSTranspiler();
-                    }
-                    plugin = await loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name);
-                    return {
-                        type: 'load-result',
-                        payload: {
-                            name: plugin.name,
-                            include: plugin.include,
-                            exclude: plugin.exclude,
-                            createNodesPattern: plugin.createNodes?.[0],
-                            hasCreateDependencies: 'createDependencies' in plugin && !!plugin.createDependencies,
-                            hasProcessProjectGraph: 'processProjectGraph' in plugin &&
-                                !!plugin.processProjectGraph,
-                            hasCreateMetadata: 'createMetadata' in plugin && !!plugin.createMetadata,
-                            hasPreTasksExecution: 'preTasksExecution' in plugin && !!plugin.preTasksExecution,
-                            hasPostTasksExecution: 'postTasksExecution' in plugin && !!plugin.postTasksExecution,
-                            success: true,
-                        },
-                    };
-                }
-                catch (e) {
-                    return {
-                        type: 'load-result',
-                        payload: {
-                            success: false,
-                            error: (0, serializable_error_1.createSerializableError)(e),
-                        },
-                    };
-                }
-            },
-            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: (0, serializable_error_1.createSerializableError)(e),
-                            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: (0, serializable_error_1.createSerializableError)(e),
-                            tx,
-                        },
-                    };
-                }
-            },
-            createMetadata: async ({ graph, context, tx }) => {
-                try {
-                    const result = await plugin.createMetadata(graph, context);
-                    return {
-                        type: 'createMetadataResult',
-                        payload: { metadata: result, success: true, tx },
-                    };
-                }
-                catch (e) {
-                    return {
-                        type: 'createMetadataResult',
-                        payload: {
-                            success: false,
-                            error: (0, serializable_error_1.createSerializableError)(e),
-                            tx,
-                        },
-                    };
-                }
-            },
-            preTasksExecution: async ({ tx, context }) => {
-                try {
-                    const mutations = await plugin.preTasksExecution?.(context);
-                    return {
-                        type: 'preTasksExecutionResult',
-                        payload: { success: true, tx, mutations },
-                    };
-                }
-                catch (e) {
-                    return {
-                        type: 'preTasksExecutionResult',
-                        payload: {
-                            success: false,
-                            error: (0, serializable_error_1.createSerializableError)(e),
-                            tx,
-                        },
-                    };
-                }
-            },
-            postTasksExecution: async ({ tx, context }) => {
-                try {
-                    await plugin.postTasksExecution?.(context);
-                    return {
-                        type: 'postTasksExecutionResult',
-                        payload: { success: true, tx },
-                    };
-                }
-                catch (e) {
-                    return {
-                        type: 'postTasksExecutionResult',
-                        payload: {
-                            success: false,
-                            error: (0, serializable_error_1.createSerializableError)(e),
-                            tx,
-                        },
-                    };
-                }
-            },
-        });
-    }));
-    // There should only ever be one host -> worker connection
-    // since the worker is spawned per host process. As such,
-    // we can safely close the worker when the host disconnects.
-    socket.on('end', () => {
-        // Destroys the socket once it's fully closed.
-        socket.destroySoon();
-        // Stops accepting new connections, but existing connections are
-        // not closed immediately.
-        server.close(() => {
-            try {
-                (0, fs_1.unlinkSync)(socketPath);
-            }
-            catch (e) { }
-            process.exit(0);
-        });
-    });
-});
-server.listen(socketPath);
-if (process.env.NX_PLUGIN_NO_TIMEOUTS !== 'true') {
-    setTimeout(() => {
-        if (!connected) {
-            console.error('The plugin worker is exiting as it was not connected to within 5 seconds.');
-            process.exit(1);
-        }
-    }, 5000).unref();
-}
-const exitHandler = (exitCode) => () => {
-    server.close();
-    try {
-        (0, fs_1.unlinkSync)(socketPath);
-    }
-    catch (e) { }
-    process.exit(exitCode);
-};
-const events = ['SIGINT', 'SIGTERM', 'SIGQUIT', 'exit'];
-events.forEach((event) => process.once(event, exitHandler(0)));
-process.once('uncaughtException', exitHandler(1));
-process.once('unhandledRejection', exitHandler(1));

package/src/project-graph/plugins/load-resolved-plugin.d.ts

@@ -1,3 +0,0 @@
-import type { PluginConfiguration } from '../../config/nx-json';
-import { LoadedNxPlugin } from './loaded-nx-plugin';
-export declare function loadResolvedNxPluginAsync(pluginConfiguration: PluginConfiguration, pluginPath: string, name: string): Promise<LoadedNxPlugin>;

package/src/project-graph/plugins/load-resolved-plugin.js

@@ -1,22 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadResolvedNxPluginAsync = loadResolvedNxPluginAsync;
-const loaded_nx_plugin_1 = require("./loaded-nx-plugin");
-async function loadResolvedNxPluginAsync(pluginConfiguration, pluginPath, name) {
-    const plugin = await importPluginModule(pluginPath);
-    plugin.name ??= name;
-    return new loaded_nx_plugin_1.LoadedNxPlugin(plugin, pluginConfiguration);
-}
-async function importPluginModule(pluginPath) {
-    const m = await Promise.resolve(`${pluginPath}`).then(s => require(s));
-    if (m.default &&
-        ('createNodes' in m.default ||
-            'createNodesV2' in m.default ||
-            'createDependencies' in m.default ||
-            'createMetadata' in m.default ||
-            'preTasksExecution' in m.default ||
-            'postTasksExecution' in m.default)) {
-        return m.default;
-    }
-    return m;
-}

package/src/project-graph/plugins/loaded-nx-plugin.d.ts

@@ -1,20 +0,0 @@
-import type { ProjectGraph } from '../../config/project-graph';
-import { type PluginConfiguration } from '../../config/nx-json';
-import type { RawProjectGraphDependency } from '../project-graph-builder';
-import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, CreateNodesResult, NxPluginV2, PostTasksExecutionContext, PreTasksExecutionContext, ProjectsMetadata } from './public-api';
-export declare class LoadedNxPlugin {
-    index?: number;
-    readonly name: string;
-    readonly createNodes?: [
-        filePattern: string,
-        fn: (matchedFiles: string[], context: CreateNodesContextV2) => Promise<Array<readonly [plugin: string, file: string, result: CreateNodesResult]>>
-    ];
-    readonly createDependencies?: (context: CreateDependenciesContext) => Promise<RawProjectGraphDependency[]>;
-    readonly createMetadata?: (graph: ProjectGraph, context: CreateMetadataContext) => Promise<ProjectsMetadata>;
-    readonly preTasksExecution?: (context: PreTasksExecutionContext) => Promise<NodeJS.ProcessEnv>;
-    readonly postTasksExecution?: (context: PostTasksExecutionContext) => Promise<void>;
-    readonly options?: unknown;
-    readonly include?: string[];
-    readonly exclude?: string[];
-    constructor(plugin: NxPluginV2, pluginDefinition: PluginConfiguration);
-}