@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,436 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IsolatedPlugin = void 0;
+const child_process_1 = require("child_process");
+const net_1 = require("net");
+const path = require("path");
+const socket_utils_1 = require("../../../daemon/socket-utils");
+const consume_messages_from_socket_1 = require("../../../utils/consume-messages-from-socket");
+const installation_directory_1 = require("../../../utils/installation-directory");
+const logger_1 = require("../../../utils/logger");
+const resolve_plugin_1 = require("../resolve-plugin");
+const messaging_1 = require("./messaging");
+const plugin_lifecycle_manager_1 = require("./plugin-lifecycle-manager");
+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.
+        2147483647
+    : 1000 * 60 * MINUTES;
+class IsolatedPlugin {
+    /**
+     * Creates and loads an isolated plugin worker.
+     */
+    static async load(plugin, root, index) {
+        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 instance = new IsolatedPlugin(plugin, root, name, pluginPath, shouldRegisterTSTranspiler, index);
+        const loadResult = await instance.spawnAndConnect();
+        instance.setupHooks(loadResult);
+        return instance;
+    }
+    constructor(plugin, root, name, pluginPath, shouldRegisterTSTranspiler, index) {
+        this.index = index;
+        // Worker state
+        this.worker = null;
+        this.socket = null;
+        this._alive = false;
+        this._connectPromise = null;
+        this.txId = 0;
+        this.pendingCount = 0;
+        // Typed response handlers keyed by transaction ID
+        this.responseHandlers = new Map();
+        this.exitHandler = null;
+        this.handleSocketData = (raw) => {
+            const message = JSON.parse(raw);
+            if (!(0, messaging_1.isPluginWorkerResult)(message)) {
+                return;
+            }
+            const pending = this.responseHandlers.get(message.tx);
+            if (pending) {
+                this.responseHandlers.delete(message.tx);
+                pending.onMessage(message);
+            }
+        };
+        this.plugin = plugin;
+        this.root = root;
+        this.name = name;
+        this.pluginPath = pluginPath;
+        this.shouldRegisterTSTranspiler = shouldRegisterTSTranspiler;
+    }
+    async spawnAndConnect() {
+        const { worker, socket } = await startPluginWorker(this.name);
+        this.worker = worker;
+        this.socket = socket;
+        this.registerProcessMetrics();
+        this.exitHandler = () => {
+            this._alive = false;
+            this._connectPromise = null;
+            if (this.worker?.stdout) {
+                this.worker.stdout.unpipe(process.stdout);
+            }
+            if (this.worker?.stderr) {
+                this.worker.stderr.unpipe(process.stderr);
+            }
+            // Reject all pending requests
+            const error = new Error(`Plugin worker "${this.name}" exited unexpectedly.`);
+            for (const { onError } of this.responseHandlers.values()) {
+                onError(error);
+            }
+            this.responseHandlers.clear();
+        };
+        worker.on('exit', this.exitHandler);
+        socket.on('data', (0, consume_messages_from_socket_1.consumeMessagesFromSocket)(this.handleSocketData));
+        return this.sendLoadMessage();
+    }
+    /**
+     * Ensures the worker is alive, restarting it if necessary.
+     * Called before each hook execution to handle plugins that were
+     * eagerly shutdown (e.g., post-task-only plugins).
+     *
+     * Uses a stored promise to coalesce concurrent restart attempts
+     * so that only one worker is ever spawned at a time.
+     */
+    async ensureAlive() {
+        if (this._alive) {
+            return;
+        }
+        if (!this._connectPromise) {
+            logger_1.logger.verbose(`[plugin-client] restarting worker for "${this.name}"`);
+            this._connectPromise = this.spawnAndConnect();
+        }
+        await this._connectPromise;
+    }
+    sendLoadMessage() {
+        return new Promise((resolve, reject) => {
+            const tx = this.generateTxId('load');
+            const timeout = setTimeout(() => {
+                this.responseHandlers.delete(tx);
+                reject(new Error(`Loading "${typeof this.plugin === 'string' ? this.plugin : this.plugin.plugin}" timed out after ${MINUTES} minutes. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
+            }, MAX_MESSAGE_WAIT);
+            this.responseHandlers.set(tx, {
+                onMessage: (msg) => {
+                    clearTimeout(timeout);
+                    if (msg.type !== 'loadResult') {
+                        reject(new Error(`Expected loadResult, got ${msg.type}`));
+                        return;
+                    }
+                    const payload = msg.payload;
+                    if (payload.success === false) {
+                        reject(payload.error);
+                    }
+                    else {
+                        this._alive = true;
+                        resolve(payload);
+                    }
+                },
+                onError: (error) => {
+                    clearTimeout(timeout);
+                    reject(error);
+                },
+            });
+            (0, messaging_1.sendMessageOverSocket)(this.socket, {
+                type: 'load',
+                payload: {
+                    plugin: this.plugin,
+                    root: this.root,
+                    name: this.name,
+                    pluginPath: this.pluginPath,
+                    shouldRegisterTSTranspiler: this.shouldRegisterTSTranspiler,
+                },
+                tx,
+            });
+        });
+    }
+    setupHooks(loadResult) {
+        // These are set via Object.defineProperty to work around readonly
+        this.name = loadResult.name;
+        this.include = loadResult.include;
+        this.exclude = loadResult.exclude;
+        const registeredHooks = hooks(loadResult.createNodesPattern && 'createNodes', loadResult.hasCreateDependencies && 'createDependencies', loadResult.hasCreateMetadata && 'createMetadata', loadResult.hasPreTasksExecution && 'preTasksExecution', loadResult.hasPostTasksExecution && 'postTasksExecution');
+        this.lifecycle = new plugin_lifecycle_manager_1.PluginLifecycleManager(registeredHooks);
+        const shutdown = () => this.shutdownIfInactive();
+        const wrap = (hook, hookFn) => this.lifecycle.wrapHook(hook, async (...args) => {
+            await this.ensureAlive();
+            return hookFn(...args);
+        }, shutdown);
+        if (loadResult.createNodesPattern) {
+            this.createNodes = [
+                loadResult.createNodesPattern,
+                wrap('createNodes', async (configFiles, ctx) => {
+                    const result = await this.sendRequest('createNodes', {
+                        configFiles,
+                        context: ctx,
+                    });
+                    if (result.success === false) {
+                        throw result.error;
+                    }
+                    return result.result;
+                }),
+            ];
+        }
+        if (loadResult.hasCreateDependencies) {
+            this.createDependencies = wrap('createDependencies', async (ctx) => {
+                const result = await this.sendRequest('createDependencies', {
+                    context: ctx,
+                });
+                if (result.success === false) {
+                    throw result.error;
+                }
+                return result.dependencies;
+            });
+        }
+        if (loadResult.hasCreateMetadata) {
+            this.createMetadata = wrap('createMetadata', async (graph, ctx) => {
+                const result = await this.sendRequest('createMetadata', {
+                    graph,
+                    context: ctx,
+                });
+                if (result.success === false) {
+                    throw result.error;
+                }
+                return result.metadata;
+            });
+        }
+        if (loadResult.hasPreTasksExecution) {
+            this.preTasksExecution = wrap('preTasksExecution', async (context) => {
+                const result = await this.sendRequest('preTasksExecution', {
+                    context,
+                });
+                if (result.success === false) {
+                    throw result.error;
+                }
+                return result.mutations;
+            });
+        }
+        if (loadResult.hasPostTasksExecution) {
+            this.postTasksExecution = wrap('postTasksExecution', async (context) => {
+                const result = await this.sendRequest('postTasksExecution', {
+                    context,
+                });
+                if (result.success === false) {
+                    throw result.error;
+                }
+            });
+        }
+        // Shut down immediately if no graph phase hooks
+        if (this.lifecycle.shouldShutdownImmediately()) {
+            this.shutdown();
+        }
+    }
+    generateTxId(type) {
+        return `${this.name}:${this.worker?.pid ?? ''}:${type}:${this.txId++}`;
+    }
+    sendRequest(type, payload) {
+        const tx = this.generateTxId(type);
+        this.pendingCount++;
+        return new Promise((resolve, reject) => {
+            const expectedResultType = `${type}Result`;
+            const timeout = setTimeout(() => {
+                this.responseHandlers.delete(tx);
+                this.pendingCount--;
+                reject(new Error(`${this.name} timed out after ${MINUTES} minutes during ${type}. ${PLUGIN_TIMEOUT_HINT_TEXT}`));
+            }, MAX_MESSAGE_WAIT);
+            this.responseHandlers.set(tx, {
+                onMessage: (msg) => {
+                    clearTimeout(timeout);
+                    this.pendingCount--;
+                    if (msg.type !== expectedResultType) {
+                        reject(new Error(`Expected ${expectedResultType}, got ${msg.type}`));
+                        return;
+                    }
+                    resolve(msg.payload);
+                },
+                onError: (error) => {
+                    clearTimeout(timeout);
+                    this.pendingCount--;
+                    reject(error);
+                },
+            });
+            (0, messaging_1.sendMessageOverSocket)(this.socket, {
+                type,
+                payload,
+                tx,
+            });
+        });
+    }
+    shutdownIfInactive() {
+        if (this.pendingCount > 0) {
+            logger_1.logger.verbose(`[isolated-plugin] worker for "${this.name}" has ${this.pendingCount} pending request(s), not shutting down yet`);
+            return;
+        }
+        logger_1.logger.verbose(`[isolated-plugin] shutting down worker for "${this.name}" after last hook`);
+        this.shutdown();
+    }
+    shutdown() {
+        if (!this._alive)
+            return;
+        this._alive = false;
+        this._connectPromise = null;
+        if (this.worker && this.exitHandler) {
+            this.worker.off('exit', this.exitHandler);
+        }
+        if (this.worker?.stdout) {
+            this.worker.stdout.unpipe(process.stdout);
+            this.worker.stdout.destroy();
+        }
+        if (this.worker?.stderr) {
+            this.worker.stderr.unpipe(process.stderr);
+            this.worker.stderr.destroy();
+        }
+        if (this.socket) {
+            this.socket.end();
+        }
+        this.worker = null;
+        this.socket = null;
+        this.exitHandler = null;
+    }
+    registerProcessMetrics() {
+        if (!this.worker?.pid)
+            return;
+        (async () => {
+            try {
+                const { isOnDaemon } = await Promise.resolve().then(() => require('../../../daemon/is-on-daemon'));
+                if (!isOnDaemon()) {
+                    const { getProcessMetricsService } = await Promise.resolve().then(() => require('../../../tasks-runner/process-metrics-service'));
+                    getProcessMetricsService().registerMainCliSubprocess(this.worker.pid, `${this.name}${this.index !== undefined ? ` (${this.index})` : ''}`);
+                }
+            }
+            catch {
+                // Silently ignore - metrics collection is optional
+            }
+        })();
+    }
+}
+exports.IsolatedPlugin = IsolatedPlugin;
+// --- Worker Spawning Utilities ---
+global.nxPluginWorkerCount ??= 0;
+async function startPluginWorker(name) {
+    performance.mark(`start-plugin-worker:${name}`);
+    const isWorkerTypescript = path.extname(__filename) === '.ts';
+    const workerPath = path.join(__dirname, 'plugin-worker');
+    const env = {
+        ...process.env,
+        ...(isWorkerTypescript
+            ? {
+                TS_NODE_PROJECT: path.join(__dirname, '../../../../tsconfig.lib.json'),
+            }
+            : {}),
+    };
+    const ipcPath = (0, socket_utils_1.getPluginOsSocketPath)([process.pid, global.nxPluginWorkerCount++, performance.now()].join('-'));
+    const worker = (0, child_process_1.spawn)(process.execPath, [
+        ...(isWorkerTypescript ? ['--require', 'ts-node/register'] : []),
+        workerPath,
+        ipcPath,
+        name,
+    ], {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env,
+        detached: true,
+        shell: false,
+        windowsHide: true,
+    });
+    logger_1.logger.verbose(`[isolated-plugin] spawned worker for "${name}" (pid: ${worker.pid}, socket: ${ipcPath})`);
+    const stdoutMaxListeners = process.stdout.getMaxListeners();
+    const stderrMaxListeners = process.stderr.getMaxListeners();
+    if (stdoutMaxListeners !== 0) {
+        process.stdout.setMaxListeners(stdoutMaxListeners + 1);
+    }
+    if (stderrMaxListeners !== 0) {
+        process.stderr.setMaxListeners(stderrMaxListeners + 1);
+    }
+    pipeAndUnrefChildStream(worker.stdout, process.stdout, 'stdout');
+    pipeAndUnrefChildStream(worker.stderr, process.stderr, 'stderr');
+    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);
+                logger_1.logger.verbose(`[isolated-plugin] connected to worker for "${name}" (pid: ${worker.pid}) after ${attempts} attempt(s)`);
+                resolve({ worker, socket });
+            }
+            else if (attempts > 10000) {
+                clearInterval(id);
+                reject(new Error(`Failed to start plugin worker for plugin ${name}`));
+            }
+            else {
+                attempts++;
+            }
+        }, 10);
+    }).finally(() => {
+        performance.mark(`start-plugin-worker-end:${name}`);
+        performance.measure(`start-plugin-worker:${name}`, `start-plugin-worker:${name}`, `start-plugin-worker-end:${name}`);
+    });
+}
+function isServerAvailable(ipcPath) {
+    return new Promise((resolve) => {
+        try {
+            const socket = (0, net_1.connect)(ipcPath, () => {
+                resolve(socket);
+            });
+            socket.once('error', () => {
+                resolve(false);
+            });
+        }
+        catch {
+            resolve(false);
+        }
+    });
+}
+function getTypeName(u) {
+    if (u === null)
+        return 'null';
+    if (u === undefined)
+        return 'undefined';
+    if (typeof u !== 'object')
+        return typeof u;
+    if (Array.isArray(u)) {
+        const innerTypes = u.map((el) => getTypeName(el));
+        return `Array<${Array.from(new Set(innerTypes)).join('|')}>`;
+    }
+    return u.constructor?.name ?? 'unknown object';
+}
+function detectAlternativeRuntime() {
+    if ('Bun' in globalThis && typeof globalThis.Bun !== 'undefined') {
+        return 'bun';
+    }
+    if ('Deno' in globalThis && typeof globalThis.Deno !== 'undefined') {
+        return 'deno';
+    }
+    return null;
+}
+function pipeAndUnrefChildStream(source, destination, streamName) {
+    if (!source) {
+        return;
+    }
+    source.pipe(destination);
+    if (source instanceof net_1.Socket) {
+        source.unref();
+        return;
+    }
+    if (typeof source.unref === 'function') {
+        source.unref();
+        return;
+    }
+    const runtime = detectAlternativeRuntime();
+    if (runtime) {
+        console.warn(`[NX] worker.${streamName} does not support unref() in ${runtime}. ` +
+            `This may cause the process to hang when waiting for plugin workers to exit. ` +
+            `This is a known limitation of ${runtime}'s Node.js compatibility layer.`);
+    }
+    else {
+        console.warn(`[NX] worker.${streamName} is not a net.Socket and does not have an unref() method. ` +
+            `Expected Socket, got ${getTypeName(source)}. ` +
+            `This may cause the process to hang when waiting for plugin workers to exit.`);
+    }
+}
+function hooks(...array) {
+    return array.filter((v) => !!v);
+}

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

@@ -0,0 +1,4 @@
+import { PluginConfiguration } from '../../../config/nx-json';
+import type { LoadedNxPlugin } from '../loaded-nx-plugin';
+export declare function loadIsolatedNxPlugin(plugin: PluginConfiguration, root: string, index?: number): Promise<[Promise<LoadedNxPlugin>, () => void]>;
+//# sourceMappingURL=load-isolated-plugin.d.ts.map

package/src/project-graph/plugins/isolation/load-isolated-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"load-isolated-plugin.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/load-isolated-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,yBAAyB,CAAC;AAE9D,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAC;AAU1D,wBAAsB,oBAAoB,CACxC,MAAM,EAAE,mBAAmB,EAC3B,IAAI,EAAE,MAAM,EACZ,KAAK,CAAC,EAAE,MAAM,GACb,OAAO,CAAC,CAAC,OAAO,CAAC,cAAc,CAAC,EAAE,MAAM,IAAI,CAAC,CAAC,CAyBhD"}

package/src/project-graph/plugins/isolation/load-isolated-plugin.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadIsolatedNxPlugin = loadIsolatedNxPlugin;
+const isolated_plugin_1 = require("./isolated-plugin");
+const isolatedPluginCache = (global['isolatedPluginCache'] ??= new Map());
+async function loadIsolatedNxPlugin(plugin, root, index) {
+    const cacheKey = JSON.stringify({ plugin, root });
+    if (isolatedPluginCache.has(cacheKey)) {
+        return [isolatedPluginCache.get(cacheKey), () => { }];
+    }
+    const pluginPromise = isolated_plugin_1.IsolatedPlugin.load(plugin, root, index).catch((err) => {
+        // Remove failed entries from cache so subsequent calls can retry
+        isolatedPluginCache.delete(cacheKey);
+        throw err;
+    });
+    isolatedPluginCache.set(cacheKey, pluginPromise);
+    const cleanup = async () => {
+        const instancePromise = isolatedPluginCache.get(cacheKey);
+        isolatedPluginCache.delete(cacheKey);
+        const instance = await instancePromise;
+        instance?.shutdown();
+    };
+    return [pluginPromise, cleanup];
+}

package/src/project-graph/plugins/isolation/message-types.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Generic message type system for socket-based IPC.
+ *
+ * Provides type-safe message definitions with automatic result type derivation.
+ * Used by the plugin worker messaging layer but generic enough for any
+ * request/response protocol over sockets.
+ */
+export interface BaseMessage {
+    tx: string;
+}
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * Constraint for message definitions.
+ * - payload: required, the message payload
+ * - result: optional, if present this message expects a response
+ */
+export type MessageDef = {
+    payload: unknown;
+    result?: unknown;
+};
+export type MessageDefs = Record<string, MessageDef>;
+/**
+ * DefineMessages<T> - purely a type-level construct for defining
+ * a set of related messages with their payloads and optional results.
+ */
+export type DefineMessages<TDefs extends MessageDefs> = TDefs;
+/** Get keys that have results defined */
+export type WithResult<TDefs extends MessageDefs> = {
+    [K in keyof TDefs]: TDefs[K] extends {
+        result: unknown;
+    } ? K : never;
+}[keyof TDefs];
+/** Extract the full message type for a given key */
+export type MessageOf<TDefs extends MessageDefs, K extends keyof TDefs> = BaseMessage & {
+    type: K;
+    payload: TDefs[K]['payload'];
+};
+/** Extract the full result type for a given key */
+export type ResultOf<TDefs extends MessageDefs, K extends WithResult<TDefs>> = BaseMessage & {
+    type: `${K & string}Result`;
+    payload: TDefs[K]['result'];
+};
+/** Union of all message types */
+export type AllMessages<TDefs extends MessageDefs> = {
+    [K in keyof TDefs & string]: MessageOf<TDefs, K>;
+}[keyof TDefs & string];
+/** Union of all result types */
+export type AllResults<TDefs extends MessageDefs> = {
+    [K in WithResult<TDefs> & string]: ResultOf<TDefs, K>;
+}[WithResult<TDefs> & string];
+/**
+ * Handler map type - handlers return just the result payload directly.
+ * The infrastructure wraps the return value in { type: '${key}Result', payload, tx }.
+ */
+export type Handlers<TDefs extends MessageDefs> = {
+    [K in keyof TDefs & string]: (payload: TDefs[K]['payload']) => TDefs[K] extends {
+        result: unknown;
+    } ? MaybePromise<TDefs[K]['result'] | void> : MaybePromise<void>;
+};
+//# sourceMappingURL=message-types.d.ts.map

package/src/project-graph/plugins/isolation/message-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"message-types.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/message-types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAC;CACZ;AAED,MAAM,MAAM,YAAY,CAAC,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,CAAC,CAAC,CAAC;AAE7C;;;;GAIG;AACH,MAAM,MAAM,UAAU,GAAG;IACvB,OAAO,EAAE,OAAO,CAAC;IACjB,MAAM,CAAC,EAAE,OAAO,CAAC;CAClB,CAAC;AAEF,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAC;AAErD;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,KAAK,SAAS,WAAW,IAAI,KAAK,CAAC;AAM9D,yCAAyC;AACzC,MAAM,MAAM,UAAU,CAAC,KAAK,SAAS,WAAW,IAAI;KACjD,CAAC,IAAI,MAAM,KAAK,GAAG,KAAK,CAAC,CAAC,CAAC,SAAS;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GAAG,CAAC,GAAG,KAAK;CACrE,CAAC,MAAM,KAAK,CAAC,CAAC;AAEf,oDAAoD;AACpD,MAAM,MAAM,SAAS,CACnB,KAAK,SAAS,WAAW,EACzB,CAAC,SAAS,MAAM,KAAK,IACnB,WAAW,GAAG;IAChB,IAAI,EAAE,CAAC,CAAC;IACR,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC;CAC9B,CAAC;AAEF,mDAAmD;AACnD,MAAM,MAAM,QAAQ,CAClB,KAAK,SAAS,WAAW,EACzB,CAAC,SAAS,UAAU,CAAC,KAAK,CAAC,IACzB,WAAW,GAAG;IAChB,IAAI,EAAE,GAAG,CAAC,GAAG,MAAM,QAAQ,CAAC;IAC5B,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC;CAC7B,CAAC;AAEF,iCAAiC;AACjC,MAAM,MAAM,WAAW,CAAC,KAAK,SAAS,WAAW,IAAI;KAClD,CAAC,IAAI,MAAM,KAAK,GAAG,MAAM,GAAG,SAAS,CAAC,KAAK,EAAE,CAAC,CAAC;CACjD,CAAC,MAAM,KAAK,GAAG,MAAM,CAAC,CAAC;AAExB,gCAAgC;AAChC,MAAM,MAAM,UAAU,CAAC,KAAK,SAAS,WAAW,IAAI;KACjD,CAAC,IAAI,UAAU,CAAC,KAAK,CAAC,GAAG,MAAM,GAAG,QAAQ,CAAC,KAAK,EAAE,CAAC,CAAC;CACtD,CAAC,UAAU,CAAC,KAAK,CAAC,GAAG,MAAM,CAAC,CAAC;AAE9B;;;GAGG;AACH,MAAM,MAAM,QAAQ,CAAC,KAAK,SAAS,WAAW,IAAI;KAC/C,CAAC,IAAI,MAAM,KAAK,GAAG,MAAM,GAAG,CAC3B,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,KACzB,KAAK,CAAC,CAAC,CAAC,SAAS;QAAE,MAAM,EAAE,OAAO,CAAA;KAAE,GACrC,YAAY,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,IAAI,CAAC,GACvC,YAAY,CAAC,IAAI,CAAC;CACvB,CAAC"}

package/src/project-graph/plugins/isolation/message-types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Generic message type system for socket-based IPC.
+ *
+ * Provides type-safe message definitions with automatic result type derivation.
+ * Used by the plugin worker messaging layer but generic enough for any
+ * request/response protocol over sockets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,127 @@
+import type { Serializable } from 'child_process';
+import type { Socket } from 'net';
+import type { PluginConfiguration } from '../../../config/nx-json';
+import type { ProjectGraph } from '../../../config/project-graph';
+import type { LoadedNxPlugin } from '../loaded-nx-plugin';
+import type { CreateDependenciesContext, CreateMetadataContext, CreateNodesContextV2, PostTasksExecutionContext, PreTasksExecutionContext } from '../public-api';
+import type { AllMessages, AllResults, DefineMessages, Handlers, ResultOf, WithResult } from './message-types';
+/**
+ * All plugin worker message definitions in one place.
+ * Each entry defines:
+ * - payload: what the message carries
+ * - result (optional): what the response carries
+ */
+type PluginMessageDefs = DefineMessages<{
+    load: {
+        payload: {
+            plugin: PluginConfiguration;
+            root: string;
+            name: string;
+            pluginPath: string;
+            shouldRegisterTSTranspiler: boolean;
+        };
+        result: {
+            name: string;
+            include?: string[];
+            exclude?: string[];
+            createNodesPattern: string;
+            hasCreateDependencies: boolean;
+            hasProcessProjectGraph: boolean;
+            hasCreateMetadata: boolean;
+            hasPreTasksExecution: boolean;
+            hasPostTasksExecution: boolean;
+            success: true;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
+    createNodes: {
+        payload: {
+            configFiles: string[];
+            context: CreateNodesContextV2;
+        };
+        result: {
+            success: true;
+            result: Awaited<ReturnType<LoadedNxPlugin['createNodes'][1]>>;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
+    createDependencies: {
+        payload: {
+            context: CreateDependenciesContext;
+        };
+        result: {
+            dependencies: Awaited<ReturnType<LoadedNxPlugin['createDependencies']>>;
+            success: true;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
+    createMetadata: {
+        payload: {
+            graph: ProjectGraph;
+            context: CreateMetadataContext;
+        };
+        result: {
+            metadata: Awaited<ReturnType<LoadedNxPlugin['createMetadata']>>;
+            success: true;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
+    preTasksExecution: {
+        payload: {
+            context: PreTasksExecutionContext;
+        };
+        result: {
+            success: true;
+            mutations: NodeJS.ProcessEnv;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
+    postTasksExecution: {
+        payload: {
+            context: PostTasksExecutionContext;
+        };
+        result: {
+            success: true;
+        } | {
+            success: false;
+            error: Error;
+        };
+    };
+}>;
+/** Union of all plugin worker message types */
+export type PluginWorkerMessage = AllMessages<PluginMessageDefs>;
+/** Union of all plugin worker result types */
+export type PluginWorkerResult = AllResults<PluginMessageDefs>;
+/** Result type for the load message */
+export type PluginWorkerLoadResult = ResultOf<PluginMessageDefs, 'load'>;
+/**
+ * Maps a message type to its result type.
+ * e.g., MessageResult<'createNodes'> gives the createNodes result type
+ */
+export type MessageResult<T extends PluginWorkerMessage['type']> = ResultOf<PluginMessageDefs, T & WithResult<PluginMessageDefs>>;
+export declare function isPluginWorkerMessage(message: Serializable): message is PluginWorkerMessage;
+export declare function isPluginWorkerResult(message: Serializable): message is PluginWorkerResult;
+/**
+ * Consumes a message and dispatches to the appropriate handler.
+ * If the handler returns a value, it's automatically wrapped in a result message
+ * with the correct type and transaction ID.
+ *
+ * Handlers return just the result payload - the infrastructure handles wrapping.
+ */
+export declare function consumeMessage(socket: Socket, raw: PluginWorkerMessage, handlers: Handlers<PluginMessageDefs>): Promise<void>;
+/**
+ * Sends a message over the socket with proper formatting.
+ */
+export declare function sendMessageOverSocket(socket: Socket, message: PluginWorkerMessage | PluginWorkerResult): void;
+export {};
+//# sourceMappingURL=messaging.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"messaging.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/project-graph/plugins/isolation/messaging.ts"],"names":[],"mappings":"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"}